diff --git a/.gitignore b/.gitignore index d8c8942..1a67eb7 100644 --- a/.gitignore +++ b/.gitignore @@ -63,3 +63,4 @@ Approved_rights/ **/.profiles/ # PowerCodex local build/compile scratch dirs .tmp-* +.superpowers/ diff --git a/desktop/scripts/sync-lifecycle.js b/desktop/scripts/sync-lifecycle.js index ddc911e..e8b882c 100644 --- a/desktop/scripts/sync-lifecycle.js +++ b/desktop/scripts/sync-lifecycle.js @@ -23,19 +23,30 @@ fs.cpSync(src, dst, { console.log('synced lifecycle →', path.relative(process.cwd(), dst)); -// The published starter is the canonical scaffold for desktop "Create a new app" -// (decision D5). Vendor it beside the engine so desktop-born projects get the full -// harness / e2e / data layout; scaffold.js resolves it at vendor/templates/starter. -const tplSrc = path.resolve(__dirname, '..', '..', 'templates', 'starter'); -const tplDst = path.resolve(__dirname, '..', 'vendor', 'templates', 'starter'); -if (fs.existsSync(tplSrc)) { - fs.rmSync(tplDst, { recursive: true, force: true }); - fs.mkdirSync(path.dirname(tplDst), { recursive: true }); - fs.cpSync(tplSrc, tplDst, { - recursive: true, - filter: (s) => !SKIP.test(s), - }); - console.log('synced starter →', path.relative(process.cwd(), tplDst)); +// Vendor the whole templates/ tree (starter + github OPSX prompts/skills + the fixed +// openspec/config.yaml) and bin/create-powercodex.js, so "✨ New project" inside the +// packaged app can spawn the exact same full scaffold the `powercodex` CLI produces +// (one CLI, two entry points — decision D5, extended). scaffold-cli.js resolves the +// vendored bin at vendor/bin/create-powercodex.js, which in turn resolves its own +// template root at vendor/templates/ relative to itself — no path changes needed +// inside create-powercodex.js itself. +const templatesSrc = path.resolve(__dirname, '..', '..', 'templates'); +const templatesDst = path.resolve(__dirname, '..', 'vendor', 'templates'); +if (fs.existsSync(templatesSrc)) { + fs.rmSync(templatesDst, { recursive: true, force: true }); + fs.mkdirSync(path.dirname(templatesDst), { recursive: true }); + fs.cpSync(templatesSrc, templatesDst, { recursive: true, filter: (s) => !SKIP.test(s) }); + console.log('synced templates →', path.relative(process.cwd(), templatesDst)); } else { - console.warn('starter template not found at', tplSrc, '— desktop scaffold will fall back to the generic template'); + console.warn('templates/ not found at', templatesSrc, '— desktop scaffold will fall back to the generic template, and "New project" will be unavailable'); +} + +const binSrc = path.resolve(__dirname, '..', '..', 'bin', 'create-powercodex.js'); +const binDst = path.resolve(__dirname, '..', 'vendor', 'bin', 'create-powercodex.js'); +if (fs.existsSync(binSrc)) { + fs.mkdirSync(path.dirname(binDst), { recursive: true }); + fs.copyFileSync(binSrc, binDst); + console.log('synced create-powercodex.js →', path.relative(process.cwd(), binDst)); +} else { + console.warn('bin/create-powercodex.js not found — "New project" will be unavailable in this build'); } diff --git a/docs/superpowers/plans/2026-07-13-desktop-terminal-action-bridge.md b/docs/superpowers/plans/2026-07-13-desktop-terminal-action-bridge.md new file mode 100644 index 0000000..69a69dc --- /dev/null +++ b/docs/superpowers/plans/2026-07-13-desktop-terminal-action-bridge.md @@ -0,0 +1,1049 @@ +# Desktop Terminal-Action Bridge Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Let the PowerCodex chat/desktop UI trigger `pac code push`, `pac code add-data-source`, and a full new-project scaffold via a button click or a typed chat request — no terminal required. + +**Architecture:** Each action is a small library function (`buildAndPush`, `addDataSource`, `scaffoldNewProject`) called from two thin entry points that already exist in this codebase — `Controller.action()` (button clicks, `/api/action`) and `agent.js`'s `run()` (chat intent, `/api/agent`) — so button and chat share one implementation per action, matching how the existing `propose-mvp` / `artifact` actions are already wired. + +**Tech Stack:** Node.js (`node:child_process` spawn, zero new dependencies), the existing zero-dependency lifecycle HTTP server, vanilla JS in `chat.html`. + +## Global Constraints + +- Every file under `tools/lifecycle/` has a byte-identical mirror at `templates/starter/tools/lifecycle/` (verified: `diff tools/lifecycle/lib/control.js templates/starter/tools/lifecycle/lib/control.js` → identical, no sync script exists). **Every edit to a `tools/lifecycle/lib/*.js` or `tools/lifecycle/assets/chat.html` file in this plan must be applied identically to both locations**, or `npm run lifecycle:selftest`'s existing lockstep check (`selftest.js:632-644`) and future drift will silently diverge the generated-app copy from the engine copy. +- `Push` and `Add datasource` change a live Power Platform environment. Both must be refused unless `Approved_rights/approval.json`'s `allowPush` flag is `true` (`tools/lifecycle/lib/rights.js` — `DEFAULTS.allowPush = false`). `Create new project` (scaffold) touches no live environment and has no gate. +- The existing action name `'create-project'` is already taken (`server.js:115` `createProject()` — scaffolds a *lightweight* starter into the *already-open, empty* workspace, no OpenSpec/OPSX/git). The new "full scaffold, brand-new named folder" feature this plan builds uses the distinct name `'scaffold-project'` throughout, so it does not collide with or change existing behavior. +- No new npm dependencies. Follow the existing `spawn` + line-parsing pattern already used in `pac-init.js` and `scaffold.js`. +- Test convention for `tools/lifecycle/lib`: there is no `node --test` suite for this directory — correctness is asserted via `tools/lifecycle/lib/selftest.js`'s `check(name, ok)` calls, run with `npm run lifecycle:selftest`. Add new checks there; do not invent a different test framework for this code. + +--- + +### Task 1: `pac-init.js` — `buildAndPush()` (build then push) + +**Files:** +- Modify: `tools/lifecycle/lib/pac-init.js` +- Modify (mirror): `templates/starter/tools/lifecycle/lib/pac-init.js` +- Test: `tools/lifecycle/lib/selftest.js` (+ mirror) + +**Interfaces:** +- Produces: `buildAndPush(root, { appDir, emit }) => Promise<{ pushed: boolean, built: boolean, output: string, error?: string }>` — exported from `pac-init.js` alongside the existing exports. Also exports `runPac(args, opts)` (an alias for the module's internal `pac()` helper), so `datasource.js` (Task 2) can spawn `pac` without duplicating the binary-resolution logic. + +- [ ] **Step 1: Add the failing selftest check** + +In `tools/lifecycle/lib/selftest.js`, immediately after the existing `pacInit` block (after line 444's `fs.rmSync(pacRoot, { recursive: true, force: true });`), add: + +```js + // ── buildAndPush: runs npm run build first when a build script exists, then push ── + const buildPushRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-buildpush-')); + fs.writeFileSync(path.join(buildPushRoot, 'package.json'), JSON.stringify({ name: 'x', scripts: { build: 'node -e "require(\'fs\').writeFileSync(\'built.txt\',\'ok\')"' } })); + const bpLog = []; + const bpPacFake = { pushed: true, output: 'push ok' }; + const bpResult = await pacInit.buildAndPush(buildPushRoot, { + emit: async ({ level, message }) => bpLog.push(`[${level}] ${message}`), + _push: async () => bpPacFake, + }); + check('buildAndPush runs the build script when present', fs.existsSync(path.join(buildPushRoot, 'built.txt'))); + check('buildAndPush reports built:true after a successful build', bpResult.built === true); + check('buildAndPush calls through to push and returns its result', bpResult.pushed === true); + const noBuildRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-buildpush-nobuild-')); + fs.writeFileSync(path.join(noBuildRoot, 'package.json'), JSON.stringify({ name: 'x' })); + const bpNoBuild = await pacInit.buildAndPush(noBuildRoot, { emit: async () => {}, _push: async () => bpPacFake }); + check('buildAndPush skips the build step when no build script exists', bpNoBuild.built === false && bpNoBuild.pushed === true); + fs.rmSync(buildPushRoot, { recursive: true, force: true }); + fs.rmSync(noBuildRoot, { recursive: true, force: true }); +``` + +- [ ] **Step 2: Run the selftest to see it fail** + +Run: `npm run lifecycle:selftest` +Expected: FAIL — `TypeError: pacInit.buildAndPush is not a function` + +- [ ] **Step 3: Implement `buildAndPush` in `pac-init.js`** + +In `tools/lifecycle/lib/pac-init.js`, add after `pushCodeApp` (before the `registerCodeApp` block) — note the `_push` injection point mirrors the existing `_pac` injection pattern used by `registerCodeApp` for deterministic testing: + +```js +// Run `npm run build` first (only if package.json declares a build script), then +// pac code push. Mirrors the maker's own "npm run build && pac code push" habit as +// one action. Never throws — callers check the returned booleans/error. +function hasBuildScript(root) { + try { + const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')); + return !!(pkg.scripts && pkg.scripts.build); + } catch { + return false; + } +} + +function runNpmBuild(root, { emit = async () => {} } = {}) { + return new Promise((resolve) => { + const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm'; + const child = spawn(npm, ['run', 'build'], { cwd: root, shell: process.platform === 'win32' }); + let out = ''; + const relay = async (b) => { out += String(b); await emit({ level: 'info', message: String(b).trim() }).catch(() => {}); }; + if (child.stdout) child.stdout.on('data', relay); + if (child.stderr) child.stderr.on('data', relay); + child.on('error', (e) => resolve({ ok: false, output: e.message })); + child.on('close', (code) => resolve({ ok: code === 0, output: out })); + }); +} + +async function buildAndPush(root, { appDir, emit = async () => {}, _push } = {}) { + const push = _push || pushCodeApp; + let built = false; + if (hasBuildScript(root)) { + await emit({ level: 'info', message: 'npm run build' }); + const b = await runNpmBuild(root, { emit }); + if (!b.ok) { + await emit({ level: 'bad', message: `npm run build failed:\n${b.output}` }); + return { pushed: false, built: false, output: b.output, error: 'build failed' }; + } + built = true; + await emit({ level: 'good', message: 'npm run build succeeded' }); + } else { + await emit({ level: 'info', message: 'no "build" script in package.json — skipping build, pushing as-is' }); + } + const result = await push(root, { appDir, emit }); + return Object.assign({ built }, result); +} +``` + +- [ ] **Step 4: Export the new functions** + +In `tools/lifecycle/lib/pac-init.js`, change the final `module.exports` line to: + +```js +module.exports = { checkPac, preflight, listAuthProfiles, ensureAuth, initCodeApp, pushCodeApp, registerCodeApp, buildAndPush, runPac: pac }; +``` + +- [ ] **Step 5: Run the selftest to see it pass** + +Run: `npm run lifecycle:selftest` +Expected: PASS on the 4 new checks (look for `✓ buildAndPush runs the build script when present`, etc.) + +- [ ] **Step 6: Mirror the two edited files into `templates/starter/`** + +```bash +cp tools/lifecycle/lib/pac-init.js templates/starter/tools/lifecycle/lib/pac-init.js +cp tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/selftest.js +diff tools/lifecycle/lib/pac-init.js templates/starter/tools/lifecycle/lib/pac-init.js +diff tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/selftest.js +``` +Expected: both `diff` calls print nothing (identical). + +- [ ] **Step 7: Commit** + +```bash +git add tools/lifecycle/lib/pac-init.js tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/pac-init.js templates/starter/tools/lifecycle/lib/selftest.js +git commit -m "feat(lifecycle): add buildAndPush — npm run build then pac code push" +``` + +--- + +### Task 2: `datasource.js` (new) — `addDataSource()` + +**Files:** +- Create: `tools/lifecycle/lib/datasource.js` +- Create (mirror): `templates/starter/tools/lifecycle/lib/datasource.js` +- Test: `tools/lifecycle/lib/selftest.js` (+ mirror) + +**Interfaces:** +- Consumes: `runPac(args, opts)` and `checkPac()` from `pac-init.js` (Task 1). +- Produces: `addDataSource(root, { api, table, appDir, emit }) => Promise<{ added: boolean, output: string, error?: string }>`. + +- [ ] **Step 1: Add the failing selftest check** + +In `tools/lifecycle/lib/selftest.js`, right after Task 1's new block, add: + +```js + // ── datasource.js: pac code add-data-source wrapper ──────────────────────── + const datasourceMod = require('./datasource'); + const dsRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-datasource-')); + const dsFakeRuns = []; + const dsFakePac = { + checkPac: async () => '1.46', + runPac: async (args) => { dsFakeRuns.push(args); return { code: 0, stdout: 'added', stderr: '' }; }, + }; + const dsOk = await datasourceMod.addDataSource(dsRoot, { api: 'dataverse', table: 'cr_invoice', emit: async () => {}, _pac: dsFakePac }); + check('addDataSource succeeds and reports added:true', dsOk.added === true); + check('addDataSource builds -a and -t flags for a Dataverse table', dsFakeRuns[0].join(' ') === ['code', 'add-data-source', '-a', 'dataverse', '-t', 'cr_invoice'].join(' ')); + const dsNoTable = await datasourceMod.addDataSource(dsRoot, { api: 'shared_sharepointonline', emit: async () => {}, _pac: dsFakePac }); + check('addDataSource omits -t for a non-Dataverse connector with no table', !dsFakeRuns[1].includes('-t')); + const dsMissingApi = await datasourceMod.addDataSource(dsRoot, { emit: async () => {}, _pac: dsFakePac }); + check('addDataSource refuses when no api/connector id is given', dsMissingApi.added === false && /api|connector/i.test(dsMissingApi.error || '')); + fs.rmSync(dsRoot, { recursive: true, force: true }); +``` + +- [ ] **Step 2: Run the selftest to see it fail** + +Run: `npm run lifecycle:selftest` +Expected: FAIL — `Cannot find module './datasource'` + +- [ ] **Step 3: Implement `datasource.js`** + +Create `tools/lifecycle/lib/datasource.js`: + +```js +'use strict'; +// datasource.js — wraps `pac code add-data-source`, wiring a Dataverse table or +// another already-connected connector into the Code App's power.config.json. +// Table logical names must already exist (created via `dataverse-schema.js`'s +// applySchema); this module only performs the pac CLI wiring step. +const pacInit = require('./pac-init'); + +// Add a data source to the Code App at `root`/`appDir`. +// api — the pac connector id, e.g. "dataverse" or a shared_* connector id +// table — required for Dataverse (a table logical name); omitted for other connectors +// `_pac` injects { checkPac, runPac } for deterministic tests (defaults to pac-init.js). +async function addDataSource(root, { api, table, appDir, emit = async () => {}, _pac } = {}) { + const p = _pac || { checkPac: pacInit.checkPac, runPac: pacInit.runPac }; + if (!api) { + return { added: false, output: '', error: 'No api/connector id given — which data source? (e.g. "dataverse")' }; + } + try { + await p.checkPac(); + } catch (e) { + return { added: false, output: '', error: e.message }; + } + const args = ['code', 'add-data-source', '-a', api]; + if (table) args.push('-t', table); + const dir = appDir || root; + await emit({ level: 'info', message: `pac ${args.join(' ')} in ${dir}` }); + const r = await p.runPac(args, { cwd: dir }); + if (r.code !== 0) { + await emit({ level: 'bad', message: `pac code add-data-source failed:\n${r.stderr || r.stdout}` }); + return { added: false, output: r.stdout + '\n' + r.stderr, error: r.stderr || r.stdout }; + } + await emit({ level: 'good', message: `Data source "${api}"${table ? ' (' + table + ')' : ''} added` }); + return { added: true, output: r.stdout }; +} + +module.exports = { addDataSource }; +``` + +- [ ] **Step 4: Run the selftest to see it pass** + +Run: `npm run lifecycle:selftest` +Expected: PASS on all 4 new checks. + +- [ ] **Step 5: Mirror into `templates/starter/`** + +```bash +cp tools/lifecycle/lib/datasource.js templates/starter/tools/lifecycle/lib/datasource.js +cp tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/selftest.js +diff tools/lifecycle/lib/datasource.js templates/starter/tools/lifecycle/lib/datasource.js +``` +Expected: no output (identical). + +- [ ] **Step 6: Commit** + +```bash +git add tools/lifecycle/lib/datasource.js tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/datasource.js templates/starter/tools/lifecycle/lib/selftest.js +git commit -m "feat(lifecycle): add datasource.js — pac code add-data-source wrapper" +``` + +--- + +### Task 3: `scaffold-cli.js` (new) — `scaffoldNewProject()` + +**Files:** +- Create: `tools/lifecycle/lib/scaffold-cli.js` +- Create (mirror): `templates/starter/tools/lifecycle/lib/scaffold-cli.js` +- Test: `tools/lifecycle/lib/selftest.js` (+ mirror) + +**Interfaces:** +- Produces: `binPath()`, `scaffoldNewProject(targetDir, { name, emit }) => Promise<{ scaffolded: boolean, projectDir?: string, output: string, error?: string }>`. + +**Context:** `bin/create-powercodex.js` (the full CLI — starter + OpenSpec + all OPSX prompts/skills + git init) only exists at the repo root, not inside a generated project. This module resolves it the same two-candidate way `scaffold.js`'s `starterDir()` already resolves `templates/starter` — repo checkout vs. the desktop app's vendored copy — and returns `null` when neither exists (e.g. inside an already-generated app, where "scaffold another brand-new PowerCodex project" isn't available), exactly the graceful-degrade convention `starterDir()` already established. + +- [ ] **Step 1: Add the failing selftest check** + +In `tools/lifecycle/lib/selftest.js`, right after Task 2's new block, add: + +```js + // ── scaffold-cli.js: spawns bin/create-powercodex.js, parses [run]/[ok]/[fail] lines ── + const scaffoldCli = require('./scaffold-cli'); + const scParent = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-scaffold-cli-')); + const scLog = []; + // Inject a fake CLI script so this never spawns npm install / git init for real. + const fakeCliPath = path.join(scParent, 'fake-create.js'); + fs.writeFileSync(fakeCliPath, ` + console.log('[run] Copy starter template'); + console.log('[ok] Copy starter template'); + console.log('[run] Initialize git repository'); + console.log('[ok] Initialize git repository'); + `); + const scOk = await scaffoldCli.scaffoldNewProject(scParent, { + name: 'demo-app', + emit: async ({ level, message }) => scLog.push(`[${level}] ${message}`), + _binPath: fakeCliPath, + }); + check('scaffoldNewProject reports scaffolded:true on a clean exit', scOk.scaffolded === true); + check('scaffoldNewProject resolves projectDir to targetDir/name', scOk.projectDir === path.join(scParent, 'demo-app')); + check('scaffoldNewProject relays [ok] lines as good-level progress', scLog.some((l) => l.startsWith('[good]') && l.includes('Copy starter template'))); + const scMissing = await scaffoldCli.scaffoldNewProject(scParent, { name: 'x', emit: async () => {}, _binPath: null }); + check('scaffoldNewProject degrades honestly when the CLI is not available', scMissing.scaffolded === false && /not available/i.test(scMissing.error || '')); + fs.rmSync(scParent, { recursive: true, force: true }); +``` + +- [ ] **Step 2: Run the selftest to see it fail** + +Run: `npm run lifecycle:selftest` +Expected: FAIL — `Cannot find module './scaffold-cli'` + +- [ ] **Step 3: Implement `scaffold-cli.js`** + +Create `tools/lifecycle/lib/scaffold-cli.js`: + +```js +'use strict'; +// scaffold-cli.js — spawns bin/create-powercodex.js (the full PowerCodex scaffold: +// starter template + OpenSpec + all 11 OPSX prompts/skills + git init) to create a +// brand-new named project, streaming its [run]/[ok]/[skip]/[fail] step lines as +// progress. Resolves the CLI across two layouts, same pattern as scaffold.js's +// starterDir(): the repo checkout (tools/lifecycle/lib → /bin) and the +// vendored desktop app (desktop/vendor/lifecycle/lib → desktop/vendor/bin). Returns +// null when neither exists (e.g. inside an already-generated app) so callers can +// degrade honestly instead of crashing. +const fs = require('node:fs'); +const path = require('node:path'); +const { spawn } = require('node:child_process'); + +function binPath() { + const candidates = [ + path.resolve(__dirname, '..', '..', '..', 'bin', 'create-powercodex.js'), + path.resolve(__dirname, '..', '..', 'bin', 'create-powercodex.js'), + ]; + return candidates.find((p) => fs.existsSync(p)) || null; +} + +const STEP_LINE = /^\[(run|ok|skip|fail)\]\s+(.+)$/; +const LEVEL = { run: 'info', ok: 'good', skip: 'info', fail: 'bad' }; + +// Create a brand-new PowerCodex project named `name` inside `targetDir`. +// `_binPath` injects the CLI script path for deterministic tests (defaults to binPath()). +function scaffoldNewProject(targetDir, { name, emit = async () => {}, _binPath } = {}) { + return new Promise((resolve) => { + const cli = _binPath !== undefined ? _binPath : binPath(); + if (!cli) { + resolve({ scaffolded: false, output: '', error: 'Full project scaffolding is not available here — the PowerCodex CLI isn’t bundled with this build.' }); + return; + } + if (!name) { + resolve({ scaffolded: false, output: '', error: 'A project name is required.' }); + return; + } + const child = spawn(process.execPath, [cli, name], { cwd: targetDir }); + let out = ''; + let err = ''; + const onLine = (line) => { + const m = line.match(STEP_LINE); + if (m) emit({ level: LEVEL[m[1]] || 'info', message: m[2] }).catch(() => {}); + }; + const relay = (buf, isErr) => { + const s = String(buf); + (isErr ? (err += s) : (out += s)); + s.split('\n').forEach((l) => l.trim() && onLine(l.trim())); + }; + if (child.stdout) child.stdout.on('data', (b) => relay(b, false)); + if (child.stderr) child.stderr.on('data', (b) => relay(b, true)); + child.on('error', (e) => resolve({ scaffolded: false, output: out, error: e.message })); + child.on('close', (code) => { + if (code !== 0) { + resolve({ scaffolded: false, output: out, error: err.trim() || `create-powercodex exited with code ${code}` }); + return; + } + resolve({ scaffolded: true, projectDir: path.join(targetDir, name), output: out }); + }); + }); +} + +module.exports = { binPath, scaffoldNewProject }; +``` + +- [ ] **Step 4: Run the selftest to see it pass** + +Run: `npm run lifecycle:selftest` +Expected: PASS on all 4 new checks. + +- [ ] **Step 5: Mirror into `templates/starter/`** + +```bash +cp tools/lifecycle/lib/scaffold-cli.js templates/starter/tools/lifecycle/lib/scaffold-cli.js +cp tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/selftest.js +diff tools/lifecycle/lib/scaffold-cli.js templates/starter/tools/lifecycle/lib/scaffold-cli.js +``` +Expected: no output. + +- [ ] **Step 6: Commit** + +```bash +git add tools/lifecycle/lib/scaffold-cli.js tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/scaffold-cli.js templates/starter/tools/lifecycle/lib/selftest.js +git commit -m "feat(lifecycle): add scaffold-cli.js — spawn create-powercodex.js for a full new-project scaffold" +``` + +--- + +### Task 4: `chat.js` — teach `classifyIntent()` push / add-datasource / scaffold-project + +**Files:** +- Modify: `tools/lifecycle/lib/chat.js` +- Modify (mirror): `templates/starter/tools/lifecycle/lib/chat.js` +- Test: `tools/lifecycle/lib/selftest.js` (+ mirror) + +**Interfaces:** +- Produces: `classifyIntent(message, history)` now also returns `'push'`, `'add-datasource'`, or `'scaffold-project'` (in addition to the existing `'chat' | 'act' | 'answer' | 'artifact' | 'plan'`). + +**Context:** Today, `deploy`, `publish`, and `push (it|this|to)` are folded into the generic `'act'` regex (`chat.js:71`), which hands the request to a free-form AI provider — there is no guarantee it actually runs `pac code push`. A bare `"push my changes"` doesn't even match that phrase and currently falls through to the default `'plan'` intent (would incorrectly start the build loop). This task carves out three precise, deterministic intents, checked before the existing `'act'` regex, and removes the now-redundant tokens from it. + +- [ ] **Step 1: Add the failing selftest checks** + +In `tools/lifecycle/lib/selftest.js`, right after Task 3's new block, add: + +```js + // ── classifyIntent: push / add-datasource / scaffold-project ─────────────── + const { classifyIntent } = require('./chat'); + check('classifyIntent recognizes "push my changes"', classifyIntent('push my changes') === 'push'); + check('classifyIntent recognizes "deploy this"', classifyIntent('deploy this') === 'push'); + check('classifyIntent recognizes "publish to my environment"', classifyIntent('publish to my environment') === 'push'); + check('classifyIntent recognizes "add a datasource for the Orders table"', classifyIntent('add a datasource for the Orders table') === 'add-datasource'); + check('classifyIntent recognizes "wire up a data source"', classifyIntent('wire up a data source') === 'add-datasource'); + check('classifyIntent recognizes "start a new project called Inspections"', classifyIntent('start a new project called Inspections') === 'scaffold-project'); + check('classifyIntent recognizes "create a new powercodex project"', classifyIntent('create a new powercodex project') === 'scaffold-project'); + check('classifyIntent leaves an unrelated build ask as plan', classifyIntent('build a screen to track tasks') === 'plan'); + check('classifyIntent leaves "fix it" as act', classifyIntent('fix it') === 'act'); +``` + +- [ ] **Step 2: Run the selftest to see it fail** + +Run: `npm run lifecycle:selftest` +Expected: FAIL — the new `push` / `add-datasource` / `scaffold-project` checks report the old values (`'act'` or `'plan'`). + +- [ ] **Step 3: Implement in `chat.js`** + +In `tools/lifecycle/lib/chat.js`, in `classifyIntent()`, insert three new checks immediately after the "Short greetings" block (before the existing "Imperative action" `'act'` check at line 71), and trim the now-redundant tokens from that `'act'` regex: + +```js + // Deterministic actions with a real, specific engine behind them — checked before + // the generic 'act' catch-all so they run the actual pac command, not a free-form + // AI guess. Order matters: scaffold-project before add-datasource ("create a new + // project" must not be read as "add a data source"). + if (/\b(start|create|make|set up|scaffold)\b.*\b(new )?(powercodex )?project\b/.test(g) || /\bnew powercodex project\b/.test(g)) { + return 'scaffold-project'; + } + if (/\b(add|wire up|connect|hook up)\b.*\b(data ?source|dataverse table|connector)\b/.test(g)) { + return 'add-datasource'; + } + if (/\b(push|deploy|publish)\b/.test(g) && !/\bpush notification/.test(g)) { + return 'push'; + } + + // Imperative action on work that already exists. + if (/\b(do it|just do it|go ahead|proceed|fix it|fix this|repair|ship it|make it live|run it|run the app|start it)\b/.test(g)) { + return 'act'; + } +``` + +(This replaces the old `'act'` regex's alternation, which previously included `deploy|publish|push (it|this|to)` — those tokens are removed since the new `push` intent above already covers them, more precisely.) + +- [ ] **Step 4: Run the selftest to see it pass** + +Run: `npm run lifecycle:selftest` +Expected: PASS on all 9 new checks, and all pre-existing `classifyIntent`/harness checks still pass (no regressions in `'plan'`/`'act'`/`'artifact'`/`'answer'` classification). + +- [ ] **Step 5: Mirror into `templates/starter/`** + +```bash +cp tools/lifecycle/lib/chat.js templates/starter/tools/lifecycle/lib/chat.js +cp tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/selftest.js +diff tools/lifecycle/lib/chat.js templates/starter/tools/lifecycle/lib/chat.js +``` +Expected: no output. + +- [ ] **Step 6: Commit** + +```bash +git add tools/lifecycle/lib/chat.js tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/chat.js templates/starter/tools/lifecycle/lib/selftest.js +git commit -m "feat(lifecycle): classify push / add-datasource / scaffold-project chat intents" +``` + +--- + +### Task 5: `control.js` — `case 'push'` and `case 'add-datasource'` + +**Files:** +- Modify: `tools/lifecycle/lib/control.js` +- Modify (mirror): `templates/starter/tools/lifecycle/lib/control.js` +- Test: `tools/lifecycle/lib/selftest.js` (+ mirror) + +**Interfaces:** +- Consumes: `pacInit.buildAndPush` (Task 1), `datasource.addDataSource` (Task 2), the already-imported `loadRights` from `./rights`. +- Produces: `Controller.action({ type: 'push', appDir? })` and `Controller.action({ type: 'add-datasource', api, table?, appDir? })`, both returning `{ ok: boolean, ... }`. + +- [ ] **Step 1: Add the failing selftest checks** + +In `tools/lifecycle/lib/selftest.js`, inside the existing "Live dashboard server" block (right after the `reflectAct` line at `selftest.js:95`, before `const after = await req(port, 'GET', '/api/state');`), add: + +```js + const pushBlocked = await req(port, 'POST', '/api/action', { type: 'push' }); + await req(port, 'POST', '/api/action', { type: 'rights', flag: 'allowPush', value: true }); + const dsBlockedThenAllowed = await req(port, 'POST', '/api/action', { type: 'add-datasource', api: 'dataverse', table: 'cr_demo' }); +``` + +And extend the `resolve({...})` object a few lines below (after `rightApplied: ...`) with: + +```js + pushGatedWhenOff: pushBlocked.json.ok === false && /allowPush|Publish/i.test(pushBlocked.json.error || ''), + addDatasourceReachable: 'ok' in dsBlockedThenAllowed.json, +``` + +Then, further down in the same function where `serverChecks` is consumed with individual `check(...)` calls (search for `check('server status endpoint returns 200'` or similar nearby existing lines), add two more: + +```js + check('push is refused while allowPush is off', serverChecks.pushGatedWhenOff); + check('add-datasource action is reachable via /api/action', serverChecks.addDatasourceReachable); +``` + +- [ ] **Step 2: Run the selftest to see it fail** + +Run: `npm run lifecycle:selftest` +Expected: FAIL — `unknown action: push` / `unknown action: add-datasource`. + +- [ ] **Step 3: Implement in `control.js`** + +In `tools/lifecycle/lib/control.js`, add two `require`s at the top: + +```js +const pacInit = require('./pac-init'); +const { addDataSource } = require('./datasource'); +``` + +Then add two new `case`s inside `Controller.action()`'s `switch`, right before the `case 'reflect':` block (`control.js:133`): + +```js + case 'push': { + const rights = loadRights(this.root); + if (!rights || rights.allowPush !== true) { + return { ok: false, error: 'Push is off — turn on "Publish to my environment" in the rights panel first' }; + } + const boundEmit = async ({ level, message }) => { emit(this.root, { rotation: 0, stage: 4, agent: 'runner', level, message }); render(this.root); }; + const result = await pacInit.buildAndPush(this.root, { appDir: body.appDir, emit: boundEmit }); + return Object.assign({ ok: result.pushed }, result); + } + case 'add-datasource': { + const rights = loadRights(this.root); + if (!rights || rights.allowPush !== true) { + return { ok: false, error: 'Add datasource is off — turn on "Publish to my environment" in the rights panel first' }; + } + const boundEmit = async ({ level, message }) => { emit(this.root, { rotation: 0, stage: 4, agent: 'runner', level, message }); render(this.root); }; + const result = await addDataSource(this.root, { api: body.api, table: body.table, appDir: body.appDir, emit: boundEmit }); + return Object.assign({ ok: result.added }, result); + } +``` + +- [ ] **Step 4: Run the selftest to see it pass** + +Run: `npm run lifecycle:selftest` +Expected: PASS on both new checks (`push is refused while allowPush is off`, `add-datasource action is reachable via /api/action`). + +- [ ] **Step 5: Mirror into `templates/starter/`** + +```bash +cp tools/lifecycle/lib/control.js templates/starter/tools/lifecycle/lib/control.js +cp tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/selftest.js +diff tools/lifecycle/lib/control.js templates/starter/tools/lifecycle/lib/control.js +``` +Expected: no output. + +- [ ] **Step 6: Commit** + +```bash +git add tools/lifecycle/lib/control.js tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/control.js templates/starter/tools/lifecycle/lib/selftest.js +git commit -m "feat(lifecycle): wire push and add-datasource into Controller.action()" +``` + +--- + +### Task 6: `agent.js` — chat-driven push / add-datasource / scaffold-project + +**Files:** +- Modify: `tools/lifecycle/lib/agent.js` +- Modify (mirror): `templates/starter/tools/lifecycle/lib/agent.js` +- Test: `tools/lifecycle/lib/selftest.js` (+ mirror) + +**Interfaces:** +- Consumes: `pacInit.buildAndPush` (Task 1), `datasource.addDataSource` (Task 2), `classifyIntent` (Task 4, already imported). +- Produces: `run()` now returns `{ kind: 'push' | 'add-datasource', ok, reply, ... }` (work done inline, same as the existing `'artifact'` branch) or `{ kind: 'scaffold-project', name }` (deferred to the server, same as the existing `'plan'` branch, because re-pointing the active workspace after scaffolding requires the closure-scoped state that only `server.js` holds). + +**Context:** `push` and `add-datasource` need no state beyond `root`, so — like the existing `'artifact'` branch — `agent.js` performs the real work itself. `scaffold-project` creates a *new* folder and must switch the live workspace to it afterward (`openProject()`), which only exists inside `server.js`'s `serve()` closure — so, like the existing `'plan'` branch, `agent.js` only classifies + extracts a name here; Task 7 does the real work server-side. + +- [ ] **Step 1: Add the failing selftest checks** + +In `tools/lifecycle/lib/selftest.js`, right after Task 4's `classifyIntent` block, add: + +```js + // ── agent.run(): push / add-datasource execute inline; scaffold-project defers ── + const agentRunRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-agent-run-')); + fs.writeFileSync(path.join(agentRunRoot, 'package.json'), JSON.stringify({ name: 'x' })); + require('./rights').ensureRights(agentRunRoot, { allowPush: true }); + const agentPushEvents = []; + const agentPushResult = await agentMod.run(agentRunRoot, { + message: 'push my changes', + emit: (e) => agentPushEvents.push(e), + _pushFn: async () => ({ pushed: true, built: false, output: 'ok' }), + }); + check('agent push intent executes inline and reports kind:push', agentPushResult.kind === 'push' && agentPushResult.ok === true); + check('agent push intent streams progress onto the bus', agentPushEvents.length > 0); + const agentDsResult = await agentMod.run(agentRunRoot, { + message: 'add a datasource for the Orders table', + emit: () => {}, + _addDataSourceFn: async () => ({ added: true, output: 'ok' }), + }); + check('agent add-datasource intent executes inline and reports kind:add-datasource', agentDsResult.kind === 'add-datasource' && agentDsResult.ok === true); + const agentScaffoldResult = await agentMod.run(agentRunRoot, { message: 'start a new project called Inspections', emit: () => {} }); + check('agent scaffold-project intent defers to the server with the extracted name', agentScaffoldResult.kind === 'scaffold-project' && agentScaffoldResult.name === 'Inspections'); + const agentScaffoldNoName = await agentMod.run(agentRunRoot, { message: 'start a new project', emit: () => {} }); + check('agent scaffold-project asks for a name when none is given', agentScaffoldNoName.kind === 'answer' && /name/i.test(agentScaffoldNoName.reply || '')); + fs.rmSync(agentRunRoot, { recursive: true, force: true }); +``` + +- [ ] **Step 2: Run the selftest to see it fail** + +Run: `npm run lifecycle:selftest` +Expected: FAIL — `kind` comes back `'act'` (or similar) for all three new messages, since `agent.js` doesn't yet branch on these intents. + +- [ ] **Step 3: Implement in `agent.js`** + +Add two `require`s near the top of `tools/lifecycle/lib/agent.js`: + +```js +const pacInit = require('./pac-init'); +const { addDataSource } = require('./datasource'); +``` + +Then, in `run()`, insert three new branches immediately after the existing `if (intent === 'artifact') { ... }` block (before the `// 3) act / answer` comment). Note the `opts` object referenced below is the same destructured argument `run(root, { message, history, provider, emit, memory: mem } = {})` already receives — extend that destructure to also pull `_pushFn` and `_addDataSourceFn`: + +```js +async function run(root, { message, history, provider, emit, memory: mem, _pushFn, _addDataSourceFn } = {}) { +``` + +```js + // 2b) A push request → run it now (same pushGate + buildAndPush as the button). + if (intent === 'push') { + let rights = null; + try { rights = rightsGate.load(root); } catch { /* fail closed below */ } + if (!rights || rights.allowPush !== true) { + return { kind: 'push', intent, ok: false, reply: 'Push is off — turn on "Publish to my environment" in the rights panel first.', provider: adapter.id, simulated }; + } + const push = _pushFn || pacInit.buildAndPush; + const result = await push(root, { emit: (e) => say(e.level, `Push · ${e.message}`) }); + say(result.pushed ? 'good' : 'bad', result.pushed ? 'Agent · push succeeded' : `Agent · push failed: ${result.error || ''}`); + return { kind: 'push', intent, ok: !!result.pushed, reply: result.pushed ? 'Pushed to your environment.' : `Push failed: ${result.error || 'see activity log'}`, provider: adapter.id, simulated }; + } + + // 2c) An add-datasource request → run it now. + if (intent === 'add-datasource') { + let rights = null; + try { rights = rightsGate.load(root); } catch { /* fail closed below */ } + if (!rights || rights.allowPush !== true) { + return { kind: 'add-datasource', intent, ok: false, reply: 'Adding a data source is off — turn on "Publish to my environment" in the rights panel first.', provider: adapter.id, simulated }; + } + const tableMatch = message.match(/\bfor (?:the )?["“]?([a-z0-9 _-]+?)["”]?\s*(?:table|entity)?\s*$/i); + const table = tableMatch ? tableMatch[1].trim() : undefined; + const addFn = _addDataSourceFn || addDataSource; + const result = await addFn(root, { api: 'dataverse', table, emit: (e) => say(e.level, `Datasource · ${e.message}`) }); + say(result.added ? 'good' : 'bad', result.added ? 'Agent · data source added' : `Agent · data source failed: ${result.error || ''}`); + return { kind: 'add-datasource', intent, ok: !!result.added, reply: result.added ? `Added the ${table || 'requested'} data source.` : `Couldn't add that data source: ${result.error || 'see activity log'}`, provider: adapter.id, simulated }; + } + + // 2d) A scaffold-project request → classify + extract a name; the server does the + // real work (Task 7) because it must re-point the active workspace afterward. + if (intent === 'scaffold-project') { + const nameMatch = message.match(/\b(?:called|named)\s+["“]?([a-z0-9][a-z0-9 _-]{1,60}?)["”]?\s*$/i); + const name = nameMatch ? nameMatch[1].trim() : null; + if (!name) { + return { kind: 'answer', intent, reply: 'What should the new project be called?', provider: adapter.id, simulated }; + } + say('info', `Agent · recognised a new-project request — "${name}"`); + return { kind: 'scaffold-project', intent, name, provider: adapter.id, simulated }; + } +``` + +- [ ] **Step 4: Run the selftest to see it pass** + +Run: `npm run lifecycle:selftest` +Expected: PASS on all 6 new checks. + +- [ ] **Step 5: Mirror into `templates/starter/`** + +```bash +cp tools/lifecycle/lib/agent.js templates/starter/tools/lifecycle/lib/agent.js +cp tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/selftest.js +diff tools/lifecycle/lib/agent.js templates/starter/tools/lifecycle/lib/agent.js +``` +Expected: no output. + +- [ ] **Step 6: Commit** + +```bash +git add tools/lifecycle/lib/agent.js tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/agent.js templates/starter/tools/lifecycle/lib/selftest.js +git commit -m "feat(lifecycle): chat-driven push / add-datasource / scaffold-project intents" +``` + +--- + +### Task 7: `server.js` — `scaffoldProject()` + routing + `/api/agent` post-processing + `/api/dataverse-state` + +**Files:** +- Modify: `tools/lifecycle/lib/server.js` +- Modify (mirror): `templates/starter/tools/lifecycle/lib/server.js` +- Test: `tools/lifecycle/lib/selftest.js` (+ mirror) + +**Interfaces:** +- Consumes: `scaffoldCli.scaffoldNewProject` (Task 3), `openProject` (existing closure function), `agent.run`'s `{ kind: 'scaffold-project', name }` result (Task 6), `dataverse-schema.js`'s `readState` (existing). +- Produces: `/api/action` handles `type: 'scaffold-project'`; `/api/agent` performs the real scaffold when `agent.run()` returns `kind: 'scaffold-project'`, mirroring the existing `kind === 'build'` post-processing block; a new `GET /api/dataverse-state` route for the Add-datasource picker (Task 8). + +- [ ] **Step 1: Add the failing selftest checks** + +In `tools/lifecycle/lib/selftest.js`, add a new block right after the existing "Live dashboard server" block closes (after the `check('...')` calls that consume `serverChecks`, i.e. after Task 5's two new `check()` lines): + +```js + // ── scaffold-project: /api/action creates a new project + re-points the workspace ── + const scaffoldParent = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-scaffold-parent-')); + const scaffoldSrv = serve(root, { port: 0 }); + const scaffoldServerChecks = await new Promise((resolve) => { + scaffoldSrv.on('listening', async () => { + const port = scaffoldSrv.address().port; + try { + const result = await req(port, 'POST', '/api/action', { type: 'scaffold-project', targetDir: scaffoldParent, name: 'demo-app' }); + scaffoldSrv.close(() => resolve({ result })); + } catch (e) { + scaffoldSrv.close(() => resolve({ error: e.message })); + } + }); + }); + // The real bin/create-powercodex.js isn't spawned against a throwaway dir in this + // fast selftest (it needs npm/git and takes real seconds); assert the route exists + // and degrades honestly (never crashes, never fabricates success) when scaffolding + // can't complete in this sandbox — the true happy path is covered by Task 3's unit + // test (fake CLI) and Task 9's manual end-to-end run. + check('scaffold-project route exists and returns a well-formed response', scaffoldServerChecks.result && 'ok' in scaffoldServerChecks.result.json); + fs.rmSync(scaffoldParent, { recursive: true, force: true }); + + // ── /api/dataverse-state: read-only table list for the Add-datasource picker ── + const dvStateRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-dvstate-')); + const { writeState: writeDvState } = require('./dataverse-schema'); + writeDvState(dvStateRoot, { tables: [{ displayName: 'Invoices', logicalName: 'cr_invoice', columns: [] }] }); + const dvSrv = serve(dvStateRoot, { port: 0 }); + const dvChecks = await new Promise((resolve) => { + dvSrv.on('listening', async () => { + const port = dvSrv.address().port; + const state = await req(port, 'GET', '/api/dataverse-state'); + dvSrv.close(() => resolve({ state })); + }); + }); + check('/api/dataverse-state returns the tables already applied to Dataverse', Array.isArray(dvChecks.state.json.tables) && dvChecks.state.json.tables[0].logicalName === 'cr_invoice'); + fs.rmSync(dvStateRoot, { recursive: true, force: true }); +``` + +- [ ] **Step 2: Run the selftest to see it fail** + +Run: `npm run lifecycle:selftest` +Expected: FAIL — `/api/action` with `type: 'scaffold-project'` falls through to `controller.action(body)` and returns `{ ok: false, error: 'unknown action: scaffold-project' }` (still well-formed, so the first check may pass — but `/api/dataverse-state` returns 404/empty, failing the second check). + +- [ ] **Step 3: Implement in `server.js`** + +Add two `require`s near the top of `tools/lifecycle/lib/server.js` (next to the existing `scaffold.js` require): + +```js +const scaffoldCli = require('./scaffold-cli'); +const dataverseSchema = require('./dataverse-schema'); +``` + +Add a new closure function inside `function serve(root, opts = {})`, right after the existing `createProject` function (`server.js:152`): + +```js + // Create a brand-new, fully-scaffolded PowerCodex project (starter + OpenSpec + all + // OPSX prompts/skills + git init — the same output as `powercodex ` on the + // command line) inside a folder the maker picked, then switch the live workspace to + // it — same "re-point activeRoot" mechanism openProject() already uses. + async function scaffoldProject(body = {}) { + const targetDir = body.targetDir; + if (!targetDir) return { ok: false, error: 'No target folder was selected' }; + let st; + try { st = fs.statSync(targetDir); } catch { return { ok: false, error: 'That folder no longer exists: ' + targetDir }; } + if (!st.isDirectory()) return { ok: false, error: 'That path is not a folder: ' + targetDir }; + const boundEmit = async ({ level, message }) => { + emit(activeRoot, { rotation: 0, stage: 0, agent: 'intake', level, message: 'New project · ' + message }); + render(activeRoot); + }; + const result = await scaffoldCli.scaffoldNewProject(targetDir, { name: body.name, emit: boundEmit }); + if (!result.scaffolded) return { ok: false, error: result.error || 'Could not scaffold the project' }; + const opened = openProject(result.projectDir); + return Object.assign({ ok: opened.ok !== false, projectDir: result.projectDir }, opened); + } +``` + +In the `/api/action` handler, add the new route right after the existing `create-project` line (`server.js:324`): + +```js + if (body.type === 'scaffold-project') return json(res, 200, await scaffoldProject(body)); +``` + +In the `/api/agent` handler, right after the existing `if (result.kind === 'build') { ... }` block closes (`server.js:316`, before `return json(res, 200, result);`), add: + +```js + if (result.kind === 'scaffold-project' && result.name) { + // Chat-driven scaffold has no folder picker (that's an Electron-only native + // capability); default to a sibling of the current workspace, same as typing + // a name with no location — matches the "usable immediately" goal without + // requiring a UI round-trip. + const parent = path.dirname(activeRoot); + const scaffolded = await scaffoldProject({ targetDir: parent, name: result.name }); + result.ok = scaffolded.ok; + result.reply = scaffolded.ok + ? `Created "${result.name}" and switched to it. It's ready to build.` + : `Couldn't create "${result.name}": ${scaffolded.error || 'see activity log'}`; + } +``` + +Add a new route for the Add-datasource picker, right after the existing `/api/plans` GET route (search for `req.url.startsWith('/api/plans')` and add this immediately after that block's closing): + +```js + if (req.method === 'GET' && req.url.startsWith('/api/dataverse-state')) { + return json(res, 200, dataverseSchema.readState(activeRoot)); + } +``` + +- [ ] **Step 4: Run the selftest to see it pass** + +Run: `npm run lifecycle:selftest` +Expected: PASS on both new checks. + +- [ ] **Step 5: Mirror into `templates/starter/`** + +```bash +cp tools/lifecycle/lib/server.js templates/starter/tools/lifecycle/lib/server.js +cp tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/selftest.js +diff tools/lifecycle/lib/server.js templates/starter/tools/lifecycle/lib/server.js +``` +Expected: no output. + +- [ ] **Step 6: Commit** + +```bash +git add tools/lifecycle/lib/server.js tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/server.js templates/starter/tools/lifecycle/lib/selftest.js +git commit -m "feat(lifecycle): wire scaffold-project routing + dataverse-state endpoint" +``` + +--- + +### Task 8: `chat.html` — Push / Add-datasource buttons + Create-new-project entry point + +**Files:** +- Modify: `tools/lifecycle/assets/chat.html` +- Modify (mirror): `templates/starter/tools/lifecycle/assets/chat.html` +- Test: `tools/lifecycle/lib/selftest.js` (+ mirror) — markup assertions, matching the existing Preview\|Code toggle check style (`selftest.js:632-644`). + +**Interfaces:** +- Consumes: `api('push', {})`, `api('add-datasource', {api, table})`, `api('scaffold-project', {targetDir, name})` (all from Task 5/7), `GET /api/dataverse-state` (Task 7), `window.pcDesktop.pickFolder()` (existing, desktop-only — falls back to the existing folder-path text input in the browser, same graceful degrade the "Open project" modal already uses). + +- [ ] **Step 1: Add the failing selftest checks** + +In `tools/lifecycle/lib/selftest.js`, inside the existing `for (const [i, p] of chatHtmlPaths.entries())` loop (`selftest.js:636-644`), add after the existing four `check(...)` lines: + +```js + check(`toolbar has a Push button gated on allowPush (${label})`, /id="pushBtn"/.test(html) && html.includes("rights.allowPush")); + check(`toolbar has an Add datasource button (${label})`, /id="datasourceBtn"/.test(html)); + check(`Add-datasource panel lists Dataverse tables from /api/dataverse-state (${label})`, /api\/dataverse-state/.test(html) && /id="dsPanel"/.test(html)); + check(`there is a Create new project entry point calling scaffold-project (${label})`, /id="newProjectBtn"/.test(html) && html.includes("'scaffold-project'")); +``` + +- [ ] **Step 2: Run the selftest to see it fail** + +Run: `npm run lifecycle:selftest` +Expected: FAIL — none of the new ids/strings exist yet. + +- [ ] **Step 3: Add the toolbar buttons** + +In `tools/lifecycle/assets/chat.html`, in the header `
` block (around line 284-292), add three buttons right before the existing ` + + +``` + +- [ ] **Step 4: Add the Add-datasource picker modal** + +Right after the existing "folder picker" overlay `
` closing tag (end of the block starting ``, around line 378), add: + +```html + +
+ +
+``` + +- [ ] **Step 5: Wire the buttons in the script** + +In `tools/lifecycle/assets/chat.html`'s script, right after the existing `$('openVSCodeBtn').onclick = openInVSCode;` line (around line 997), add: + +```js + // ---------- Push ---------- + $('pushBtn').onclick = async () => { + $('pushBtn').disabled = true; + bubble('me', 'Push 🚀'); + const r = await api('push', {}); + bubble('ai', r.ok ? '✅ Pushed to your environment.' : '⚠️ ' + esc(r.error || 'Push failed')); + if(app.treeRoot) loadTree(); + }; + + // ---------- Add datasource ---------- + async function openDatasourcePanel(){ + $('dsOverlay').classList.add('open'); + const sel = $('dsTableSelect'); + sel.innerHTML = ''; + try { + const state = await (await fetch('/api/dataverse-state', {cache:'no-store'})).json(); + (state.tables||[]).forEach(t => { if(t.logicalName){ const o=document.createElement('option'); o.value=t.logicalName; o.textContent=t.displayName+' ('+t.logicalName+')'; sel.appendChild(o); } }); + } catch { /* picker still usable via the free-text connector field */ } + } + $('datasourceBtn').onclick = openDatasourcePanel; + $('dsClose').onclick = () => $('dsOverlay').classList.remove('open'); + $('dsOverlay').onclick = (e) => { if(e.target===$('dsOverlay')) $('dsOverlay').classList.remove('open'); }; + $('dsGo').onclick = async () => { + const table = $('dsTableSelect').value; + const connector = $('dsConnectorInput').value.trim(); + $('dsOverlay').classList.remove('open'); + bubble('me', table ? 'Add datasource: '+table : (connector ? 'Add datasource: '+connector : 'Add datasource')); + const r = await api('add-datasource', table ? {api:'dataverse', table} : {api: connector}); + bubble('ai', r.ok ? '✅ Data source added.' : '⚠️ ' + esc(r.error || 'Could not add that data source')); + }; + + // ---------- Create new project ---------- + $('newProjectBtn').onclick = async () => { + const name = prompt('Project name:'); + if(!name) return; + let targetDir = null; + if(window.pcDesktop && window.pcDesktop.pickFolder) targetDir = await window.pcDesktop.pickFolder(); + if(!targetDir) targetDir = prompt('Folder to create it in (absolute path):'); + if(!targetDir) return; + bubble('me', 'New project: '+name); + const typing = showTyping(); + const r = await api('scaffold-project', {targetDir, name}); + typing.remove(); + bubble('ai', r.ok ? '✅ Created "'+esc(name)+'" and switched to it. It’s ready to build.' : '⚠️ ' + esc(r.error || 'Could not create the project')); + if(r.ok){ loadTree(); } + }; +``` + +- [ ] **Step 6: Gate the Push/Add-datasource buttons on `allowPush`** + +In the existing `paintStatus(state)` function (find it — called from `tick()` at `chat.html:577`), add at the end of its body: + +```js + const rights = (state.intake && state.intake.rights) || {}; + $('pushBtn').disabled = rights.allowPush !== true; + $('datasourceBtn').title = rights.allowPush === true ? 'Wire up a Dataverse table or connector' : 'Turn on "Publish to my environment" first'; +``` + +- [ ] **Step 7: Run the selftest to see it pass** + +Run: `npm run lifecycle:selftest` +Expected: PASS on all 4 new checks (both the engine and vendored-starter copies, once Step 8 mirrors the file). + +- [ ] **Step 8: Mirror into `templates/starter/`** + +```bash +cp tools/lifecycle/assets/chat.html templates/starter/tools/lifecycle/assets/chat.html +cp tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/lib/selftest.js +diff tools/lifecycle/assets/chat.html templates/starter/tools/lifecycle/assets/chat.html +``` +Expected: no output. + +- [ ] **Step 9: Manual smoke test** + +Run: `npm run lifecycle:serve -- --open` from the repo root, open the chat UI, confirm: "🚀 Push" is greyed out until you flip "Publish to my environment" on in the status panel; "🧩 Add datasource" opens the picker and lists any tables in `.powercodex/dataverse.json` if present; "✨ New project" prompts for a name and folder and, on a real run (not the selftest's faked CLI), actually creates a full PowerCodex project there. + +- [ ] **Step 10: Commit** + +```bash +git add tools/lifecycle/assets/chat.html tools/lifecycle/lib/selftest.js templates/starter/tools/lifecycle/assets/chat.html templates/starter/tools/lifecycle/lib/selftest.js +git commit -m "feat(chat): add Push, Add datasource, and New project to the toolbar" +``` + +--- + +### Task 9: `desktop/scripts/sync-lifecycle.js` — vendor the CLI + full templates dir + +**Files:** +- Modify: `desktop/scripts/sync-lifecycle.js` + +**Interfaces:** +- Consumes: nothing new — this only changes what gets copied into `desktop/vendor/` before `npm start`/`npm run dist`. +- Produces: `desktop/vendor/bin/create-powercodex.js` and `desktop/vendor/templates/` (the whole `templates/` tree, not just `templates/starter/`), so `scaffold-cli.js`'s `binPath()` candidate `path.resolve(__dirname, '..', '..', 'bin', 'create-powercodex.js')` (Task 3) resolves inside the packaged desktop app, and the spawned CLI's own `templateRoot = path.resolve(__dirname, '..', 'templates')` (in `bin/create-powercodex.js`, unmodified) finds `templates/github` and `templates/openspec` alongside `templates/starter`. + +**Context:** Without this task, "✨ New project" works when running `npm start` inside the repo checkout (Task 3's repo-checkout candidate resolves), but silently fails with "Full project scaffolding is not available here" in the packaged `.exe`/`.dmg` — because today `sync-lifecycle.js` only vendors `tools/lifecycle` and `templates/starter`, never `bin/` or `templates/github`/`templates/openspec`. This is a real production gap in the design as originally approved; fixing it here keeps "one CLI, two entry points" true instead of only true in dev mode. + +- [ ] **Step 1: Manually verify the current gap** + +Run: `cd desktop && npm install && npm run sync && ls vendor/` +Expected: `vendor/bin` does **not** exist; `vendor/templates/` contains only `starter/`, not `github/` or `openspec/`. + +- [ ] **Step 2: Update `sync-lifecycle.js`** + +In `desktop/scripts/sync-lifecycle.js`, replace the "vendor the starter template" block (from `// The published starter is the canonical scaffold...` to the end of the file) with: + +```js +// Vendor the whole templates/ tree (starter + github OPSX prompts/skills + the fixed +// openspec/config.yaml) and bin/create-powercodex.js, so "✨ New project" inside the +// packaged app can spawn the exact same full scaffold the `powercodex` CLI produces +// (one CLI, two entry points — decision D5, extended). scaffold-cli.js resolves the +// vendored bin at vendor/bin/create-powercodex.js, which in turn resolves its own +// template root at vendor/templates/ relative to itself — no path changes needed +// inside create-powercodex.js itself. +const templatesSrc = path.resolve(__dirname, '..', '..', 'templates'); +const templatesDst = path.resolve(__dirname, '..', 'vendor', 'templates'); +if (fs.existsSync(templatesSrc)) { + fs.rmSync(templatesDst, { recursive: true, force: true }); + fs.mkdirSync(path.dirname(templatesDst), { recursive: true }); + fs.cpSync(templatesSrc, templatesDst, { recursive: true, filter: (s) => !SKIP.test(s) }); + console.log('synced templates →', path.relative(process.cwd(), templatesDst)); +} else { + console.warn('templates/ not found at', templatesSrc, '— desktop scaffold will fall back to the generic template, and "New project" will be unavailable'); +} + +const binSrc = path.resolve(__dirname, '..', '..', 'bin', 'create-powercodex.js'); +const binDst = path.resolve(__dirname, '..', 'vendor', 'bin', 'create-powercodex.js'); +if (fs.existsSync(binSrc)) { + fs.mkdirSync(path.dirname(binDst), { recursive: true }); + fs.copyFileSync(binSrc, binDst); + console.log('synced create-powercodex.js →', path.relative(process.cwd(), binDst)); +} else { + console.warn('bin/create-powercodex.js not found — "New project" will be unavailable in this build'); +} +``` + +Also update `desktop/package.json`'s `"files"` array to include the vendored `bin/` alongside the existing `vendor/**/*` glob — verify `"files": ["main.js", "preload.js", "vendor/**/*", "package.json"]` already covers it (`vendor/**/*` is recursive, so `vendor/bin/create-powercodex.js` is included automatically — no change needed there; just confirm after Step 3). + +- [ ] **Step 3: Re-run sync and verify** + +Run: `cd desktop && npm run sync && ls vendor/bin && ls vendor/templates` +Expected: `vendor/bin/create-powercodex.js` exists; `vendor/templates/` contains `starter/`, `github/`, and `openspec/`. + +- [ ] **Step 4: Manual end-to-end smoke test** + +Run: `cd desktop && npm start`, click "✨ New project", give it a name and an empty target folder, confirm a real project is created there with `.github/prompts/`, `openspec/config.yaml`, and a git repo initialized — the same output `powercodex ` produces from the terminal. + +- [ ] **Step 5: Commit** + +```bash +git add desktop/scripts/sync-lifecycle.js +git commit -m "fix(desktop): vendor bin/create-powercodex.js + full templates/ so New project works in the packaged app" +``` diff --git a/docs/superpowers/specs/2026-07-13-desktop-terminal-action-bridge-design.md b/docs/superpowers/specs/2026-07-13-desktop-terminal-action-bridge-design.md new file mode 100644 index 0000000..32a04ed --- /dev/null +++ b/docs/superpowers/specs/2026-07-13-desktop-terminal-action-bridge-design.md @@ -0,0 +1,69 @@ +# Desktop terminal-action bridge + +**Status:** approved (design), not yet planned/implemented +**Date:** 2026-07-13 +**Author:** Manfred Siew (design session with Claude Code) + +## Problem + +The PowerCodex desktop app (`desktop/`) wraps the lifecycle chat UI (`tools/lifecycle/assets/chat.html`) in an Electron shell. The chat UI already bridges one terminal action end-to-end — "⚡ Build this" — through `Controller.action()` in `tools/lifecycle/lib/control.js`. Three more terminal actions a Code Apps maker regularly needs are **not** bridged: + +- **Push** — `pac code push` exists as a working wrapper (`pushCodeApp()` in `tools/lifecycle/lib/pac-init.js`) and as a CLI subcommand (`code-push`), but `Controller.action()` has no case for it, so the chat UI can't call it. +- **Add datasource** — `pac code add-data-source` is only referenced as guidance text for the AI agent (`CODEAPPS['dataverse-specialist']` / `CODEAPPS['connector-integrator']` in `tools/lifecycle/lib/harness.js`). No wrapper function exists anywhere. +- **Create new project** — the full scaffold (starter template, OpenSpec, all 11 OPSX prompts/skills, npm install, git init) is `bin/create-powercodex.js`, a separate top-level CLI (`powercodex my-app`). The desktop app only has "📂 Open project" (pick an existing folder) — nothing scaffolds a new one from inside the app. + +The user should not need to leave the app or touch a terminal for these three actions. Clicking a button (or asking in chat) should be enough. + +## Goal + +Bridge all three actions into the chat UI using the same mechanism the app already uses for "Build this": a `Controller.action()` case that both a toolbar button and the chat agent call identically, streaming progress into the existing activity feed. + +## Non-goals (explicitly skipped for v1) + +- **No connector browser for non-Dataverse sources.** Free-text connector id only, until there's a real `pac connection list` wrapper to build a picker from. +- **No solution-aware push (`--solutionName`).** `alm-engineer` guidance mentions solutions as the unit of movement, but wiring Push to a specific solution is a distinct feature. v1 pushes to the default target the same way `pushCodeApp()` does today. +- **No rollback UI for Add-datasource.** Dataverse schema changes aren't cleanly reversible via the CLI anyway; the `allowPush` consent gate is the safety net, not an undo button. + +## Design + +### Core pattern + +Every new action is one more `case` in `Controller.action()` (`tools/lifecycle/lib/control.js:44`) — the same switch that already handles `intake` / `approve` / `propose-mvp` / etc. This gives the button and the chat agent a single code path for free: + +- The button calls `api('push', {...})` (the same `api()` helper `chat.html` already uses for every other action). +- The chat agent, when it recognizes intent in a typed message, calls the identical action. + +No duplicated logic between "clicked" and "typed" — one implementation, two entry points. + +### 1. Push (`case 'push'`) + +- Wraps the existing `pushCodeApp()` from `tools/lifecycle/lib/pac-init.js`. +- Runs `npm run build` first if the workspace has a `build` script, then `pac code push`. +- Streams `pac` stdout/stderr into the activity feed via `emit()`, the same pattern `applySchema` already uses for Dataverse table creation. +- **Gate:** reuses the existing `allowPush` rights flag (the rights panel's "Publish to my environment" toggle). The button is disabled/tooltipped when `allowPush` is off; the chat path returns the same "Push is off — turn on Publish to my environment first" message the gate already produces elsewhere. +- **UI:** new "🚀 Push" toolbar button next to "⚡ Build this". +- **Chat intent:** recognizes phrases like "push", "deploy", "publish". + +### 2. Add datasource (`case 'add-datasource'`) + +- New module `tools/lifecycle/lib/datasource.js`, same spawn/emit shape as `pac-init.js`, wrapping `pac code add-data-source -a -t `. +- Unlike Push, this needs a parameter — no zero-input path: + - **Dataverse:** button opens a small panel listing tables already created via the Rule 1 browser flow, read from `.powercodex/dataverse.json` (`dataverse-schema.js`'s existing state file). + - **Other connectors:** free-text connector id field (see Non-goals — no picker yet). +- **Chat intent:** e.g. "add a datasource for the Orders table" — the agent extracts the table name and calls the same action. If it can't confidently identify a table/connector, it asks a clarifying question in chat rather than guessing. +- Guidance surfaced to the agent reuses the existing `CODEAPPS['dataverse-specialist']` / `CODEAPPS['connector-integrator']` text in `harness.js` — no new guidance text is authored. +- **Gate:** reuses `allowPush` (schema/data-source wiring is a live-environment change too). + +### 3. Create new project (`case 'create-project'`) + +- Spawns `node bin/create-powercodex.js ` as a child process into a folder the user picks via the existing native picker (`pcDesktop.pickFolder()`). +- Streams the CLI's real step names ("Copy starter template", "Initialize OpenSpec", "Finalize OPSX assets", etc. — from `create-powercodex.js`'s own `runStep()` calls) into the activity feed. +- On success, the app re-opens the new folder as the active workspace automatically (reusing the existing "open project" flow) — usable immediately, no extra step. +- **No gate** — purely local scaffolding, touches no live environment. +- **Chat intent:** e.g. "start a new project called Orders Tracker" — same action; if no name is given, asks for one (reusing `create-powercodex.js`'s existing `validateProjectName` error messages for consistency, rather than re-implementing validation). + +## Cross-cutting notes + +- All three actions follow the existing `emit()`-per-step convention, so the activity feed is the single "what happened" surface — no new progress UI to build. +- All three are exposed at the same `Controller.action()` switch, keeping button and chat-agent entry points identical. +- Skill guidance (the `CODEAPPS` object in `harness.js`) is already loaded into the agent's context for relevant tasks; these actions reuse that wiring rather than duplicating guidance text. diff --git a/package-lock.json b/package-lock.json index 2759b56..cd1f52b 100644 --- a/package-lock.json +++ b/package-lock.json @@ -392,7 +392,6 @@ "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz", "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==", "license": "MIT", - "peer": true, "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", @@ -597,7 +596,6 @@ "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.25.tgz", "integrity": "sha512-2NFaIyNVgJmBs/ecmtGzlmluTFs5cHEWGTdu0t1HBwYzoGXOL5nUQBRMXsXWla5i4KkG//QMzVP88m1+I3fdAQ==", "license": "MIT", - "peer": true, "engines": { "node": ">=16.9.0" } @@ -1164,7 +1162,6 @@ "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz", "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==", "license": "MIT", - "peer": true, "funding": { "url": "https://github.com/sponsors/colinhacks" } diff --git a/templates/starter/tools/lifecycle/assets/chat.html b/templates/starter/tools/lifecycle/assets/chat.html index 6067298..e92391d 100644 --- a/templates/starter/tools/lifecycle/assets/chat.html +++ b/templates/starter/tools/lifecycle/assets/chat.html @@ -288,6 +288,9 @@ + + + @@ -377,6 +380,16 @@ + +
+ +
+
@@ -640,6 +653,9 @@ $('spCoverage').textContent = state.test && state.test.coverage!=null ? state.test.coverage+'%' : (state.intake && state.intake.compliance!=null ? state.intake.compliance+'%' : '—'); $('spIssues').textContent = state.stopped ? 'needs you' : String((state.notifications||[]).filter(n=>n.kind==='approval').length); $('spLast').textContent = (state.feed && state.feed[0] && state.feed[0].message) ? state.feed[0].message.slice(0,42) : '—'; + const rights = (state.intake && state.intake.rights) || {}; + $('pushBtn').disabled = rights.allowPush !== true; + $('datasourceBtn').title = rights.allowPush === true ? 'Wire up a Dataverse table or connector' : 'Turn on "Publish to my environment" first'; } // ---------- canvas ---------- @@ -995,6 +1011,54 @@ $('treeRefresh').onclick = ()=> loadTree(); makeSplit($('splitTree'),'left'); makeSplit($('splitCanvas'),'right'); $('openVSCodeBtn').onclick = openInVSCode; + + // ---------- Push ---------- + $('pushBtn').onclick = async () => { + $('pushBtn').disabled = true; + bubble('me', 'Push 🚀'); + const r = await api('push', {}); + bubble('ai', r.ok ? '✅ Pushed to your environment.' : '⚠️ ' + esc(r.error || 'Push failed')); + if(app.treeRoot) loadTree(); + }; + + // ---------- Add datasource ---------- + async function openDatasourcePanel(){ + $('dsOverlay').classList.add('open'); + const sel = $('dsTableSelect'); + sel.innerHTML = ''; + try { + const state = await (await fetch('/api/dataverse-state', {cache:'no-store'})).json(); + (state.tables||[]).forEach(t => { if(t.logicalName){ const o=document.createElement('option'); o.value=t.logicalName; o.textContent=t.displayName+' ('+t.logicalName+')'; sel.appendChild(o); } }); + } catch { /* picker still usable via the free-text connector field */ } + } + $('datasourceBtn').onclick = openDatasourcePanel; + $('dsClose').onclick = () => $('dsOverlay').classList.remove('open'); + $('dsOverlay').onclick = (e) => { if(e.target===$('dsOverlay')) $('dsOverlay').classList.remove('open'); }; + $('dsGo').onclick = async () => { + const table = $('dsTableSelect').value; + const connector = $('dsConnectorInput').value.trim(); + $('dsOverlay').classList.remove('open'); + bubble('me', table ? 'Add datasource: '+esc(table) : (connector ? 'Add datasource: '+esc(connector) : 'Add datasource')); + const r = await api('add-datasource', table ? {api:'dataverse', table} : {api: connector}); + bubble('ai', r.ok ? '✅ Data source added.' : '⚠️ ' + esc(r.error || 'Could not add that data source')); + }; + + // ---------- Create new project ---------- + $('newProjectBtn').onclick = async () => { + const name = prompt('Project name:'); + if(!name) return; + let targetDir = null; + if(window.pcDesktop && window.pcDesktop.pickFolder) targetDir = await window.pcDesktop.pickFolder(); + if(!targetDir) targetDir = prompt('Folder to create it in (absolute path):'); + if(!targetDir) return; + bubble('me', 'New project: '+esc(name)); + const typing = showTyping(); + const r = await api('scaffold-project', {targetDir, name}); + typing.remove(); + bubble('ai', r.ok ? '✅ Created "'+esc(name)+'" and switched to it. It’s ready to build.' : '⚠️ ' + esc(r.error || 'Could not create the project')); + if(r.ok){ loadTree(); } + }; + $('setupRecheck').onclick = recheckSetup; $('setupSkip').onclick = ()=>{ app.skippedSetup=true; closeSetup(); }; $('setupOverlay').onclick = (e)=>{ if(e.target===$('setupOverlay')){ app.skippedSetup=true; closeSetup(); } }; diff --git a/templates/starter/tools/lifecycle/lib/agent.js b/templates/starter/tools/lifecycle/lib/agent.js index 468e0ff..48b6307 100644 --- a/templates/starter/tools/lifecycle/lib/agent.js +++ b/templates/starter/tools/lifecycle/lib/agent.js @@ -19,6 +19,8 @@ const artifacts = require('./artifacts'); const memory = require('./memory'); const harness = require('./harness'); const rightsGate = require('./rights'); +const pacInit = require('./pac-init'); +const { addDataSource } = require('./datasource'); function oneLine(s) { return String(s == null ? '' : s).replace(/\s+/g, ' ').trim(); @@ -57,7 +59,7 @@ function buildAgentPrompt({ message, history, memory: mem, rights } = {}) { // Run the agent. `emit` (optional) streams structured activity onto the bus; the server // passes one bound to the active root. Returns a result the server/client act on. -async function run(root, { message, history, provider, emit, memory: mem } = {}) { +async function run(root, { message, history, provider, emit, memory: mem, _pushFn, _addDataSourceFn } = {}) { const adapter = providers.resolve(provider); const simulated = adapter.simulated === true; const intent = classifyIntent(message, history); @@ -101,13 +103,53 @@ async function run(root, { message, history, provider, emit, memory: mem } = {}) return { kind: 'artifact', intent, - reply: entry ? `Done — I built a ${kind.replace(/-/g, ' ')} and opened it in the canvas. Tell me what to change.` : `I couldn’t create that artifact: ${err}`, + reply: entry ? `Done — I built a ${kind.replace(/-/g, ' ')} and opened it in the canvas. Tell me what to change.` : `I couldn't create that artifact: ${err}`, artifact: entry, provider: adapter.id, simulated, }; } + // 2b) A push request → run it now (same pushGate + buildAndPush as the button). + if (intent === 'push') { + let rights = null; + try { rights = rightsGate.load(root); } catch { /* fail closed below */ } + if (!rights || rights.allowPush !== true) { + return { kind: 'push', intent, ok: false, reply: 'Push is off — turn on "Publish to my environment" in the rights panel first.', provider: adapter.id, simulated }; + } + const push = _pushFn || pacInit.buildAndPush; + const result = await push(root, { emit: (e) => say(e.level, `Push · ${e.message}`) }); + say(result.pushed ? 'good' : 'bad', result.pushed ? 'Agent · push succeeded' : `Agent · push failed: ${result.error || ''}`); + return { kind: 'push', intent, ok: !!result.pushed, reply: result.pushed ? 'Pushed to your environment.' : `Push failed: ${result.error || 'see activity log'}`, provider: adapter.id, simulated }; + } + + // 2c) An add-datasource request → run it now. + if (intent === 'add-datasource') { + let rights = null; + try { rights = rightsGate.load(root); } catch { /* fail closed below */ } + if (!rights || rights.allowPush !== true) { + return { kind: 'add-datasource', intent, ok: false, reply: 'Adding a data source is off — turn on "Publish to my environment" in the rights panel first.', provider: adapter.id, simulated }; + } + const tableMatch = message.match(/\bfor (?:the )?["“]?([a-z0-9 _-]+?)["”]?\s*(?:table|entity)?\s*$/i); + const table = tableMatch ? tableMatch[1].trim() : undefined; + const addFn = _addDataSourceFn || addDataSource; + const result = await addFn(root, { api: 'dataverse', table, emit: (e) => say(e.level, `Datasource · ${e.message}`) }); + say(result.added ? 'good' : 'bad', result.added ? 'Agent · data source added' : `Agent · data source failed: ${result.error || ''}`); + return { kind: 'add-datasource', intent, ok: !!result.added, reply: result.added ? `Added the ${table || 'requested'} data source.` : `Couldn't add that data source: ${result.error || 'see activity log'}`, provider: adapter.id, simulated }; + } + + // 2d) A scaffold-project request → classify + extract a name; the server does the + // real work (Task 7) because it must re-point the active workspace afterward. + if (intent === 'scaffold-project') { + const nameMatch = message.match(/\b(?:called|named)\s+["“]?([a-z0-9][a-z0-9 _-]{1,60}?)["”]?\s*$/i); + const name = nameMatch ? nameMatch[1].trim() : null; + if (!name) { + return { kind: 'answer', intent, reply: 'What name should the new project have?', provider: adapter.id, simulated }; + } + say('info', `Agent · recognised a new-project request — "${name}"`); + return { kind: 'scaffold-project', intent, name, provider: adapter.id, simulated }; + } + // 3) act / answer → drive the provider inside the workspace. let rights = null; try { @@ -159,7 +201,7 @@ async function run(root, { message, history, provider, emit, memory: mem } = {}) const reply = text.replace(/```html[\s\S]*?```/i, '').trim() || (simulated - ? 'I can carry that out here. Connect Claude Code (the CLI) and Agent mode will read and edit your project directly; until then I’m running the simulated brain.' + ? 'I can carry that out here. Connect Claude Code (the CLI) and Agent mode will read and edit your project directly; until then I\'m running the simulated brain.' : 'Done.'); say(simulated ? 'warn' : 'good', simulated ? 'Agent · simulated (no AI CLI found)' : 'Agent · done'); diff --git a/templates/starter/tools/lifecycle/lib/chat.js b/templates/starter/tools/lifecycle/lib/chat.js index 9a953df..c2c58fe 100644 --- a/templates/starter/tools/lifecycle/lib/chat.js +++ b/templates/starter/tools/lifecycle/lib/chat.js @@ -67,8 +67,22 @@ function classifyIntent(message, history) { return 'chat'; } + // Deterministic actions with a real, specific engine behind them — checked before + // the generic 'act' catch-all so they run the actual pac command, not a free-form + // AI guess. Order matters: scaffold-project before add-datasource ("create a new + // project" must not be read as "add a data source"). + if (/\b(start|create|make|set up|scaffold)\s+(a\s+|an\s+)?new (powercodex )?project\b/.test(g) || /\bnew powercodex project\b/.test(g)) { + return 'scaffold-project'; + } + if (/\b(add|wire up|connect|hook up)\b.*\b(data ?source|dataverse table|connector)\b/.test(g)) { + return 'add-datasource'; + } + if (/\bpush (my changes|this|it)\b|\bdeploy (this|it)\b|\bpublish (this|it)\b|\bpublish to\b/.test(g)) { + return 'push'; + } + // Imperative action on work that already exists. - if (/\b(do it|just do it|go ahead|proceed|fix it|fix this|repair|deploy|publish|ship it|make it live|push (it|this|to)|run it|run the app|start it)\b/.test(g)) { + if (/\b(do it|just do it|go ahead|proceed|fix it|fix this|repair|ship it|make it live|run it|run the app|start it)\b/.test(g)) { return 'act'; } diff --git a/templates/starter/tools/lifecycle/lib/control.js b/templates/starter/tools/lifecycle/lib/control.js index f9f27a3..44dabe4 100644 --- a/templates/starter/tools/lifecycle/lib/control.js +++ b/templates/starter/tools/lifecycle/lib/control.js @@ -9,6 +9,8 @@ const freeze = require('./freeze'); const { buildStories, saveStories, refineStories, readStories } = require('./stories'); const { readDigest } = require('./digest'); const providers = require('./providers'); +const pacInit = require('./pac-init'); +const { addDataSource } = require('./datasource'); // Server-side controller: turns dashboard actions into real effects on the // status bus, the rights gate, and a running loop. Held in memory by `serve`. @@ -130,6 +132,24 @@ class Controller { render(this.root); return { ok: true, artifact, status: 'draft' }; } + case 'push': { + const rights = loadRights(this.root); + if (!rights || rights.allowPush !== true) { + return { ok: false, error: 'Push is off — turn on "Publish to my environment" in the rights panel first' }; + } + const boundEmit = async ({ level, message }) => { emit(this.root, { rotation: 0, stage: 4, agent: 'runner', level, message }); render(this.root); }; + const result = await pacInit.buildAndPush(this.root, { appDir: body.appDir, emit: boundEmit }); + return Object.assign({ ok: result.pushed }, result); + } + case 'add-datasource': { + const rights = loadRights(this.root); + if (!rights || rights.allowPush !== true) { + return { ok: false, error: 'Add datasource is off — turn on "Publish to my environment" in the rights panel first' }; + } + const boundEmit = async ({ level, message }) => { emit(this.root, { rotation: 0, stage: 4, agent: 'runner', level, message }); render(this.root); }; + const result = await addDataSource(this.root, { api: body.api, table: body.table, appDir: body.appDir, emit: boundEmit }); + return Object.assign({ ok: result.added }, result); + } case 'reflect': { const lesson = reflect(this.root, { title: body.title || 'Lesson from this session', severity: body.severity, what: body.what, how: body.how }); render(this.root); diff --git a/templates/starter/tools/lifecycle/lib/datasource.js b/templates/starter/tools/lifecycle/lib/datasource.js new file mode 100644 index 0000000..eb64815 --- /dev/null +++ b/templates/starter/tools/lifecycle/lib/datasource.js @@ -0,0 +1,35 @@ +'use strict'; +// datasource.js — wraps `pac code add-data-source`, wiring a Dataverse table or +// another already-connected connector into the Code App's power.config.json. +// Table logical names must already exist (created via `dataverse-schema.js`'s +// applySchema); this module only performs the pac CLI wiring step. +const pacInit = require('./pac-init'); + +// Add a data source to the Code App at `root`/`appDir`. +// api — the pac connector id, e.g. "dataverse" or a shared_* connector id +// table — required for Dataverse (a table logical name); omitted for other connectors +// `_pac` injects { checkPac, runPac } for deterministic tests (defaults to pac-init.js). +async function addDataSource(root, { api, table, appDir, emit = async () => {}, _pac } = {}) { + const p = _pac || { checkPac: pacInit.checkPac, runPac: pacInit.runPac }; + if (!api) { + return { added: false, output: '', error: 'No api/connector id given — which data source? (e.g. "dataverse")' }; + } + try { + await p.checkPac(); + } catch (e) { + return { added: false, output: '', error: e.message }; + } + const args = ['code', 'add-data-source', '-a', api]; + if (table) args.push('-t', table); + const dir = appDir || root; + await emit({ level: 'info', message: `pac ${args.join(' ')} in ${dir}` }); + const r = await p.runPac(args, { cwd: dir }); + if (r.code !== 0) { + await emit({ level: 'bad', message: `pac code add-data-source failed:\n${r.stderr || r.stdout}` }); + return { added: false, output: r.stdout + '\n' + r.stderr, error: r.stderr || r.stdout }; + } + await emit({ level: 'good', message: `Data source "${api}"${table ? ' (' + table + ')' : ''} added` }); + return { added: true, output: r.stdout }; +} + +module.exports = { addDataSource }; diff --git a/templates/starter/tools/lifecycle/lib/pac-init.js b/templates/starter/tools/lifecycle/lib/pac-init.js new file mode 100644 index 0000000..0a290a1 --- /dev/null +++ b/templates/starter/tools/lifecycle/lib/pac-init.js @@ -0,0 +1,264 @@ +'use strict'; +// pac-init.js — wraps the Power Platform CLI (pac) to quick-start a Code App. +// +// Sequence: +// 1. Check pac is installed and reachable. +// 2. Optionally authenticate (pac auth create --environment ). +// 3. Run pac code init to scaffold the hosted Code App entry point. +// 4. Return the result so the caller can push the initial commit. +// +// The pac binary lives at ~/.dotnet/tools/pac on macOS/Linux when installed via +// dotnet tool install --global Microsoft.PowerApps.CLI.Tool. + +const { execFile, spawn } = require('node:child_process'); +const { promisify } = require('node:util'); +const path = require('node:path'); +const fs = require('node:fs'); + +const execAsync = promisify(execFile); + +// Resolve the pac executable: try PATH first, then ~/.dotnet/tools/pac. +function findPac() { + const candidates = ['pac']; + const home = process.env.HOME || process.env.USERPROFILE || ''; + if (home) { + candidates.push(path.join(home, '.dotnet', 'tools', 'pac')); + candidates.push(path.join(home, '.dotnet', 'tools', 'pac.exe')); + } + // On Windows the dotnet tool install puts it in USERPROFILE\.dotnet\tools + if (process.env.USERPROFILE) { + candidates.push(path.join(process.env.USERPROFILE, '.dotnet', 'tools', 'pac.exe')); + } + for (const c of candidates) { + try { + // A quick sync check; not perfect but avoids spawning for each candidate. + if (fs.existsSync(c)) return c; + } catch { /* skip */ } + } + // Fall back to 'pac' and let the OS raise "not found". + return 'pac'; +} + +const PAC = findPac(); + +// Run pac and return { stdout, stderr, code }. Never throws — callers check code. +async function pac(args, { cwd = process.cwd(), env } = {}) { + return new Promise((resolve) => { + const child = spawn(PAC, args, { cwd, env: env || process.env, stdio: 'pipe' }); + let stdout = ''; + let stderr = ''; + child.stdout.on('data', (d) => { stdout += d; }); + child.stderr.on('data', (d) => { stderr += d; }); + child.on('close', (code) => resolve({ stdout: stdout.trim(), stderr: stderr.trim(), code: code ?? 0 })); + child.on('error', (e) => resolve({ stdout: '', stderr: e.message, code: 1 })); + }); +} + +// Check that pac is available and return its version string. +async function checkPac() { + const r = await pac(['help']); + if (r.code !== 0 && !r.stdout) { + throw new Error( + `pac CLI not found or not executable.\n` + + `Install it with:\n dotnet tool install --global Microsoft.PowerApps.CLI.Tool\n` + + `Then restart your terminal.` + ); + } + // pac help exits 0 and prints a usage block; extract version if present. + const vm = (r.stdout + r.stderr).match(/Version:\s*([\d.]+\S*)/i); + return vm ? vm[1] : '(unknown version)'; +} + +// List active pac auth profiles. Returns array of { name, kind, url, isActive }. +async function listAuthProfiles() { + const r = await pac(['auth', 'list']); + if (r.code !== 0) return []; + // Output lines look like: [1] Active UNIVERSAL user@tenant.com https://... ... + return r.stdout.split('\n').filter((l) => /\[(\d+)\]/.test(l)).map((line) => { + const active = /active/i.test(line); + const urlM = line.match(/(https?:\/\/[^\s]+)/i); + return { line: line.trim(), isActive: active, url: urlM ? urlM[1] : '' }; + }); +} + +// Create a pac auth profile for the given environment URL. +// If already authenticated to this environment, this is a no-op. +async function ensureAuth(environmentUrl, { emit = async () => {} } = {}) { + const profiles = await listAuthProfiles(); + const existing = profiles.find((p) => environmentUrl && p.url && p.url.startsWith(environmentUrl.replace(/\/$/, ''))); + if (existing) { + await emit({ level: 'info', message: `pac auth: already authenticated to ${environmentUrl}` }); + return { authenticated: true, reused: true }; + } + await emit({ level: 'info', message: `pac auth create --environment ${environmentUrl}` }); + const r = await pac(['auth', 'create', '--environment', environmentUrl]); + if (r.code !== 0) { + throw new Error(`pac auth create failed:\n${r.stderr || r.stdout}`); + } + await emit({ level: 'good', message: 'pac auth: authenticated successfully' }); + return { authenticated: true, reused: false, output: r.stdout }; +} + +// Pre-flight check (Fix 1.5): verify pac is reachable and — when an environment URL +// is given — that an auth profile already matches it, BEFORE a long operation begins. +// Turns a confusing mid-run failure into a precise, actionable message up front. +// Throws on failure; the MCP boundary turns the throw into a structured isError. +async function preflight({ environmentUrl, emit = async () => {} } = {}) { + const version = await checkPac(); // throws an actionable "install pac" message if missing + await emit({ level: 'info', message: `pac ${version} reachable` }); + if (environmentUrl) { + const profiles = await listAuthProfiles(); + const base = environmentUrl.replace(/\/$/, ''); + const match = profiles.find((p) => p.url && p.url.startsWith(base)); + if (!match) { + throw new Error( + `No pac auth profile matches ${environmentUrl}.\n` + + `Authenticate first with:\n pac auth create --environment ${environmentUrl}`, + ); + } + await emit({ level: 'good', message: `pac auth profile found for ${environmentUrl}` }); + } + return true; +} + +// Run pac code init to scaffold the Power Apps Code App entry in the given directory. +// This is the "quick start" — creates the hosted component structure pac expects +// before you can pac code push. +// +// Options: +// appName — the display name for the Code App +// outputDir — where to create the app scaffold (defaults to root/src) +// environmentUrl — if provided, ensure auth first +// emit — async progress callback +// +// Returns: { initialised, appDir, output, error } +async function initCodeApp(root, { + appName = 'MyPowerApp', + outputDir, + environmentUrl, + emit = async () => {}, +} = {}) { + const version = await checkPac().catch((e) => { throw e; }); + await emit({ level: 'info', message: `pac ${version} · initialising Code App "${appName}"` }); + + if (environmentUrl) { + await ensureAuth(environmentUrl, { emit }); + } + + const appDir = outputDir || path.join(root, 'src'); + fs.mkdirSync(appDir, { recursive: true }); + + await emit({ level: 'info', message: `pac code init --name "${appName}" in ${appDir}` }); + const r = await pac(['code', 'init', '--name', appName], { cwd: appDir }); + + if (r.code !== 0) { + await emit({ level: 'bad', message: `pac code init failed:\n${r.stderr || r.stdout}` }); + return { initialised: false, appDir, output: r.stdout + '\n' + r.stderr, error: r.stderr || r.stdout }; + } + + await emit({ level: 'good', message: `Code App "${appName}" initialised in ${appDir}` }); + + // Detect the generated directory name (pac creates a sub-folder named after appName). + const generatedDir = path.join(appDir, appName); + const actualDir = fs.existsSync(generatedDir) ? generatedDir : appDir; + + return { initialised: true, appDir: actualDir, output: r.stdout }; +} + +// Push code to Power Apps using pac code push. +// Call this after initCodeApp + your build step. +async function pushCodeApp(root, { appDir, emit = async () => {} } = {}) { + const dir = appDir || path.join(root, 'src'); + await checkPac(); // fail fast with an actionable message if pac is missing (Fix 1.5) + await emit({ level: 'info', message: `pac code push in ${dir}` }); + const r = await pac(['code', 'push'], { cwd: dir }); + if (r.code !== 0) { + await emit({ level: 'bad', message: `pac code push failed:\n${r.stderr || r.stdout}` }); + return { pushed: false, output: r.stdout + '\n' + r.stderr, error: r.stderr }; + } + await emit({ level: 'good', message: 'pac code push succeeded' }); + return { pushed: true, output: r.stdout }; +} + +// Decide + perform Code App registration for a freshly-built project, degrading +// gracefully. This is the whole "make it a real Power Apps Code App" contract in one +// place so the loop stays thin and the behaviour is testable without a live pac: +// • already a Code App (power.config.json present) → no-op. +// • pac not reachable → a plain-language nudge to finish Power Platform setup. +// • pac reachable → run `pac code init` at the project root; on failure, nudge. +// Never throws. Returns { registered, skipped?, level?, message? } — the loop emits +// `message` (if any) with `level`; the reachable-success path emits inside initCodeApp. +// `_pac` injects the pac boundary for tests (defaults to this module's real functions). +async function registerCodeApp(root, { appName = 'MyPowerApp', environmentUrl, emit = async () => {}, _pac } = {}) { + if (fs.existsSync(path.join(root, 'power.config.json'))) return { registered: true, skipped: true }; + const api = _pac || { checkPac, initCodeApp }; + const reachable = await api.checkPac().then(() => true).catch(() => false); + if (!reachable) { + return { + registered: false, + level: 'info', + message: 'Built as code · finish Power Platform setup (install/sign in to pac) to register this as a live Power Apps Code App', + }; + } + try { + const r = await api.initCodeApp(root, { appName, outputDir: root, environmentUrl, emit }); + return { registered: !!r.initialised, appDir: r.appDir }; + } catch (e) { + const first = e && e.message ? String(e.message).split('\n')[0] : 'pac code init failed'; + return { + registered: false, + level: 'warn', + message: `Could not register the Power Apps Code App yet: ${first} · finish Power Platform setup, then rebuild`, + }; + } +} + +// Run `npm run build` first (only if package.json declares a build script), then +// pac code push. Mirrors the maker's own "npm run build && pac code push" habit as +// one action. Never throws — callers check the returned booleans/error. +function hasBuildScript(root) { + try { + const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')); + return !!(pkg.scripts && pkg.scripts.build); + } catch { + return false; + } +} + +function runNpmBuild(root, { emit = async () => {} } = {}) { + return new Promise((resolve) => { + const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm'; + const child = spawn(npm, ['run', 'build'], { cwd: root, shell: process.platform === 'win32' }); + let out = ''; + const relay = async (b) => { out += String(b); await emit({ level: 'info', message: String(b).trim() }).catch(() => {}); }; + if (child.stdout) child.stdout.on('data', relay); + if (child.stderr) child.stderr.on('data', relay); + child.on('error', (e) => resolve({ ok: false, output: e.message })); + child.on('close', (code) => resolve({ ok: code === 0, output: out })); + }); +} + +async function buildAndPush(root, { appDir, emit = async () => {}, _push } = {}) { + const push = _push || pushCodeApp; + let built = false; + if (hasBuildScript(root)) { + await emit({ level: 'info', message: 'npm run build' }); + const b = await runNpmBuild(root, { emit }); + if (!b.ok) { + await emit({ level: 'bad', message: `npm run build failed:\n${b.output}` }); + return { pushed: false, built: false, output: b.output, error: 'build failed' }; + } + built = true; + await emit({ level: 'good', message: 'npm run build succeeded' }); + } else { + await emit({ level: 'info', message: 'no "build" script in package.json — skipping build, pushing as-is' }); + } + try { + const result = await push(root, { appDir, emit }); + return Object.assign({ built }, result); + } catch (e) { + return { pushed: false, built, output: '', error: e.message }; + } +} + +module.exports = { checkPac, preflight, listAuthProfiles, ensureAuth, initCodeApp, pushCodeApp, registerCodeApp, buildAndPush, runPac: pac }; diff --git a/templates/starter/tools/lifecycle/lib/scaffold-cli.js b/templates/starter/tools/lifecycle/lib/scaffold-cli.js new file mode 100644 index 0000000..94552d6 --- /dev/null +++ b/templates/starter/tools/lifecycle/lib/scaffold-cli.js @@ -0,0 +1,64 @@ +'use strict'; +// scaffold-cli.js — spawns bin/create-powercodex.js (the full PowerCodex scaffold: +// starter template + OpenSpec + all 11 OPSX prompts/skills + git init) to create a +// brand-new named project, streaming its [run]/[ok]/[skip]/[fail] step lines as +// progress. Resolves the CLI across two layouts, same pattern as scaffold.js's +// starterDir(): the repo checkout (tools/lifecycle/lib → /bin) and the +// vendored desktop app (desktop/vendor/lifecycle/lib → desktop/vendor/bin). Returns +// null when neither exists (e.g. inside an already-generated app) so callers can +// degrade honestly instead of crashing. +const fs = require('node:fs'); +const path = require('node:path'); +const { spawn } = require('node:child_process'); + +function binPath() { + const candidates = [ + path.resolve(__dirname, '..', '..', '..', 'bin', 'create-powercodex.js'), + path.resolve(__dirname, '..', '..', 'bin', 'create-powercodex.js'), + ]; + return candidates.find((p) => fs.existsSync(p)) || null; +} + +const STEP_LINE = /^\[(run|ok|skip|fail)\]\s+(.+)$/; +const LEVEL = { run: 'info', ok: 'good', skip: 'info', fail: 'bad' }; + +// Create a brand-new PowerCodex project named `name` inside `targetDir`. +// `_binPath` injects the CLI script path for deterministic tests (defaults to binPath()). +function scaffoldNewProject(targetDir, { name, emit = async () => {}, _binPath } = {}) { + return new Promise((resolve) => { + const cleanName = name ? String(name).replace(/[^a-zA-Z0-9 _-]/g, '').trim() : ''; + const cli = _binPath !== undefined ? _binPath : binPath(); + if (!cli) { + resolve({ scaffolded: false, output: '', error: 'Full project scaffolding is not available here — the PowerCodex CLI isn\'t bundled with this build.' }); + return; + } + if (!cleanName) { + resolve({ scaffolded: false, output: '', error: 'A project name is required.' }); + return; + } + const child = spawn(process.execPath, [cli, cleanName], { cwd: targetDir }); + let out = ''; + let err = ''; + const onLine = (line) => { + const m = line.match(STEP_LINE); + if (m) emit({ level: LEVEL[m[1]] || 'info', message: m[2] }).catch(() => {}); + }; + const relay = (buf, isErr) => { + const s = String(buf); + (isErr ? (err += s) : (out += s)); + s.split('\n').forEach((l) => l.trim() && onLine(l.trim())); + }; + if (child.stdout) child.stdout.on('data', (b) => relay(b, false)); + if (child.stderr) child.stderr.on('data', (b) => relay(b, true)); + child.on('error', (e) => resolve({ scaffolded: false, output: out, error: e.message })); + child.on('close', (code) => { + if (code !== 0) { + resolve({ scaffolded: false, output: out, error: err.trim() || `create-powercodex exited with code ${code}` }); + return; + } + resolve({ scaffolded: true, projectDir: path.join(targetDir, cleanName), output: out }); + }); + }); +} + +module.exports = { binPath, scaffoldNewProject }; diff --git a/templates/starter/tools/lifecycle/lib/selftest.js b/templates/starter/tools/lifecycle/lib/selftest.js index f3fc1f3..6f2afc4 100644 --- a/templates/starter/tools/lifecycle/lib/selftest.js +++ b/templates/starter/tools/lifecycle/lib/selftest.js @@ -64,7 +64,7 @@ async function selftest() { check('Approved_rights/approval.json created', fs.existsSync(approvalFile(root))); check('all 7 lifecycle stages emitted (0..6)', [0, 1, 2, 3, 4, 5, 6].every((s) => stages.has(s))); check('build executor produced assets', events.some((e) => e.agent === 'build-executor' && e.level === 'good')); - check('run step honored push-vs-dev rule', events.some((e) => e.agent === 'runner' && /power-apps push|npm run dev/.test(e.message))); + check('run step honored push-vs-dev rule', events.some((e) => e.agent === 'runner' && /pac code push|npm run dev/.test(e.message))); check('self-heal triggered at least once', summary.selfHeals >= 1); check('observer authored a spec from observation', summary.observations >= 1); check('loop finished without false stop', summary.stopped === false); @@ -93,6 +93,10 @@ async function selftest() { const emitted = await req(port, 'POST', '/api/emit', { agent: 'claude', message: 'self-test progress ping', level: 'good' }); const mvpAct = await req(port, 'POST', '/api/action', { type: 'propose-mvp', goal: 'track projects' }); const reflectAct = await req(port, 'POST', '/api/action', { type: 'reflect', title: 'server lesson' }); + const pushBlocked = await req(port, 'POST', '/api/action', { type: 'push' }); + const dsBlocked = await req(port, 'POST', '/api/action', { type: 'add-datasource', api: 'dataverse', table: 'cr_demo' }); + await req(port, 'POST', '/api/action', { type: 'rights', flag: 'allowPush', value: true }); + const dsBlockedThenAllowed = await req(port, 'POST', '/api/action', { type: 'add-datasource', api: 'dataverse', table: 'cr_demo' }); const after = await req(port, 'GET', '/api/state'); srv.close(() => resolve({ @@ -101,6 +105,9 @@ async function selftest() { intakeApplied: intake.json.ok && after.json.intake.goal === 'track projects and tasks', complianceComputed: after.json.intake.complianceDetail && after.json.intake.compliance >= 60, rightApplied: right.json.ok && after.json.intake.rights.allowBuild === true, + pushGatedWhenOff: pushBlocked.json.ok === false && /allowPush|Publish/i.test(pushBlocked.json.error || ''), + addDatasourceGatedWhenOff: dsBlocked.json.ok === false && /allowPush|Publish/i.test(dsBlocked.json.error || ''), + addDatasourceReachable: 'ok' in dsBlockedThenAllowed.json, emitShown: emitted.json.ok && after.json.feed.some((e) => e.agent === 'claude'), mvpAct: mvpAct.json.ok && !!mvpAct.json.path, reflectAct: reflectAct.json.ok && !!reflectAct.json.lesson, @@ -121,6 +128,9 @@ async function selftest() { check('POST /api/action propose-mvp generates an MVP', serverChecks.mvpAct); check('POST /api/action reflect logs a lesson', serverChecks.reflectAct); check('state exposes computed insights', serverChecks.hasInsights); + check('push is refused while allowPush is off', serverChecks.pushGatedWhenOff); + check('add-datasource is refused while allowPush is off', serverChecks.addDatasourceGatedWhenOff); + check('add-datasource action is reachable via /api/action', serverChecks.addDatasourceReachable); // Pure-function + module checks for the refinement features. check('compliance scores alignment', scoreCompliance('track projects and tasks', 'grid to track projects and tasks').aligned === true); @@ -220,6 +230,44 @@ async function selftest() { check('live server serves the generated plan HTML', planServerChecks.pageOk); check('live server serves the user guide at /guide', planServerChecks.guideOk); + // ── scaffold-project: /api/action creates a new project + re-points the workspace ── + // The real bin/create-powercodex.js is NOT spawned in this fast selftest — we ensure this + // by passing a non-existent targetDir, which causes scaffoldProject()'s own fs.statSync + // check to fail fast (before it ever reaches scaffoldCli.scaffoldNewProject) with + // "That folder no longer exists." This guard gates the spawn, so the test is deterministic, + // network-free, and never mutates global npm state. The happy path (real CLI, real spawn, + // real scaffold) is covered by Task 3's unit test (fake CLI injection) and end-to-end runs. + const scaffoldParent = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-scaffold-parent-')); + fs.rmSync(scaffoldParent, { recursive: true, force: true }); // deleted on purpose: forces scaffoldProject()'s own fs.statSync check to fail fast, before it ever reaches scaffoldCli.scaffoldNewProject() + const scaffoldSrv = serve(root, { port: 0 }); + const scaffoldServerChecks = await new Promise((resolve) => { + scaffoldSrv.on('listening', async () => { + const port = scaffoldSrv.address().port; + try { + const result = await req(port, 'POST', '/api/action', { type: 'scaffold-project', targetDir: scaffoldParent, name: 'demo-app' }); + scaffoldSrv.close(() => resolve({ result })); + } catch (e) { + scaffoldSrv.close(() => resolve({ error: e.message })); + } + }); + }); + check('scaffold-project route fails fast on missing target folder without spawning real CLI', scaffoldServerChecks.result && scaffoldServerChecks.result.json.ok === false && /no longer exists/i.test(scaffoldServerChecks.result.json.error || '')); + + // ── /api/dataverse-state: read-only table list for the Add-datasource picker ── + const dvStateRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-dvstate-')); + const { writeState: writeDvState } = require('./dataverse-schema'); + writeDvState(dvStateRoot, { tables: [{ displayName: 'Invoices', logicalName: 'cr_invoice', columns: [] }] }); + const dvSrv = serve(dvStateRoot, { port: 0 }); + const dvChecks = await new Promise((resolve) => { + dvSrv.on('listening', async () => { + const port = dvSrv.address().port; + const state = await req(port, 'GET', '/api/dataverse-state'); + dvSrv.close(() => resolve({ state })); + }); + }); + check('/api/dataverse-state returns the tables already applied to Dataverse', Array.isArray(dvChecks.state.json.tables) && dvChecks.state.json.tables[0].logicalName === 'cr_invoice'); + fs.rmSync(dvStateRoot, { recursive: true, force: true }); + // Portable import into a throwaway "any project". const impRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-import-')); fs.writeFileSync(path.join(impRoot, 'package.json'), JSON.stringify({ name: 'acme-portal', scripts: { dev: 'vite' }, devDependencies: { vite: '^5' } }, null, 2)); @@ -232,6 +280,53 @@ async function selftest() { check('import configures the chosen providers', Array.isArray(imp.config.providers) && imp.config.providers.length >= 1); fs.rmSync(impRoot, { recursive: true, force: true }); + // ── desktop "Create a new app" lands the full starter, not the generic template ── + // (decision D5): harness, e2e suite, and lifecycle tooling from birth. Assertions + // mirror scripts/verify-generated-project.js so the CLI and desktop scaffolds agree. + const { scaffoldFromStarter, starterDir } = require('./scaffold'); + check('starter template is resolvable for the desktop scaffold', !!starterDir()); + const newAppRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-newapp-')); + const scaf = scaffoldFromStarter(newAppRoot, { name: 'Field Reports' }); + check('desktop scaffold copies the starter (not the generic template)', !!scaf && scaf.source === 'starter' && scaf.created === true); + check('scaffolded app ships the agent harness (tools/lifecycle)', fs.existsSync(path.join(newAppRoot, 'tools', 'lifecycle', 'bin', 'powercodex-lifecycle.js'))); + check('scaffolded app ships the e2e suite (e2e/home.spec.ts)', fs.existsSync(path.join(newAppRoot, 'e2e', 'home.spec.ts'))); + check('scaffolded app ships telemetry + playwright config', fs.existsSync(path.join(newAppRoot, 'src', 'telemetry', 'app-telemetry.ts')) && fs.existsSync(path.join(newAppRoot, 'playwright.config.ts'))); + const newPkg = JSON.parse(fs.readFileSync(path.join(newAppRoot, 'package.json'), 'utf8')); + check('scaffolded package.json carries the starter scripts (e2e/lint/test/lifecycle:selftest)', ['e2e', 'lint', 'test', 'lifecycle:selftest'].every((s) => newPkg.scripts && newPkg.scripts[s])); + check('scaffolded package.json is renamed from the template to the project', newPkg.name === 'field-reports'); + fs.rmSync(newAppRoot, { recursive: true, force: true }); + + // ── scaffold-cli.js: spawns bin/create-powercodex.js, parses [run]/[ok]/[fail] lines ── + const scaffoldCli = require('./scaffold-cli'); + const scParent = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-scaffold-cli-')); + const scLog = []; + // Inject a fake CLI script so this never spawns npm install / git init for real. + const fakeCliPath = path.join(scParent, 'fake-create.js'); + fs.writeFileSync(fakeCliPath, ` + console.log('[run] Copy starter template'); + console.log('[ok] Copy starter template'); + console.log('[run] Initialize git repository'); + console.log('[ok] Initialize git repository'); + `); + const scOk = await scaffoldCli.scaffoldNewProject(scParent, { + name: 'demo-app', + emit: async ({ level, message }) => scLog.push(`[${level}] ${message}`), + _binPath: fakeCliPath, + }); + check('scaffoldNewProject reports scaffolded:true on a clean exit', scOk.scaffolded === true); + check('scaffoldNewProject resolves projectDir to targetDir/name', scOk.projectDir === path.join(scParent, 'demo-app')); + const scTraversal = await scaffoldCli.scaffoldNewProject(scParent, { + name: '../../etc', + emit: async () => {}, + _binPath: fakeCliPath, + }); + check('scaffoldNewProject sanitizes a path-traversal-shaped name before building projectDir', !scTraversal.projectDir || scTraversal.projectDir.startsWith(scParent + path.sep)); + check('scaffoldNewProject relays [ok] lines as good-level progress', scLog.some((l) => l.startsWith('[good]') && l.includes('Copy starter template'))); + check('create-powercodex.js is resolvable for the scaffold-cli (repo checkout)', !!scaffoldCli.binPath()); + const scMissing = await scaffoldCli.scaffoldNewProject(scParent, { name: 'x', emit: async () => {}, _binPath: null }); + check('scaffoldNewProject degrades honestly when the CLI is not available', scMissing.scaffolded === false && /not available/i.test(scMissing.error || '')); + fs.rmSync(scParent, { recursive: true, force: true }); + // ── brownfield ingestion · code-grounded intake · freeze ───────────────── const { buildDigest, writeDigest, readDigest } = require('./digest'); const { buildStories, readStories, refineStories } = require('./stories'); @@ -361,7 +456,7 @@ async function selftest() { check('a maker recipe falls back to the portal home without an env', /^https:\/\/make\.powerapps\.com$/.test(tableRecipe.url(null))); check('the Power Automate recipe targets make.powerautomate.com', /make\.powerautomate\.com/.test(recipeFor('powerautomate.flow.create').url('ENV123'))); check('table.create now has real DOM automation (build fn)', tableRecipe.automated === true && typeof tableRecipe.build === 'function'); - check('recipes without DOM automation yet stay honest (column.add)', recipeFor('dataverse.column.add').automated === false && typeof recipeFor('dataverse.column.add').todo === 'string'); + check('column.add now has real DOM automation (build fn)', recipeFor('dataverse.column.add').automated === true && typeof recipeFor('dataverse.column.add').build === 'function'); // Edge profile picker — discover from a Local State file, resolve a selection, persist it. const edgeProfiles = require('./edge-profiles'); @@ -408,6 +503,333 @@ async function selftest() { fs.rmSync(cgRoot, { recursive: true, force: true }); } + // ── Gap #2: real Code App registration (pac) — degrade contract ─────────── + // The build stage turns a plain React app into a compliant Power Apps Code App by + // running `pac code init` (writes power.config.json). It must degrade honestly when + // pac is absent/unauthed: a plain-language nudge, never a crash, never a fabricated + // marker. Inject the pac boundary so this is deterministic regardless of whether pac + // happens to be installed on the machine running the test. + const pacInit = require('./pac-init'); + const pacRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-pac-')); + const pacAbsent = { checkPac: async () => { throw new Error('pac CLI not found'); } }; + const regDegraded = await pacInit.registerCodeApp(pacRoot, { appName: 'demo', _pac: pacAbsent }); + check('code-app registration degrades to a plain-language nudge when pac is absent', regDegraded.registered === false && /finish Power Platform setup/i.test(regDegraded.message || '')); + check('code-app registration never fabricates power.config.json without pac', !fs.existsSync(path.join(pacRoot, 'power.config.json'))); + const pacFake = { checkPac: async () => '1.0', initCodeApp: async (r) => { fs.writeFileSync(path.join(r, 'power.config.json'), '{}'); return { initialised: true, appDir: r }; } }; + const regOk = await pacInit.registerCodeApp(pacRoot, { appName: 'demo', _pac: pacFake }); + check('code-app registration runs pac code init when pac is reachable', regOk.registered === true && fs.existsSync(path.join(pacRoot, 'power.config.json'))); + const regSkip = await pacInit.registerCodeApp(pacRoot, { appName: 'demo', _pac: pacFake }); + check('code-app registration is a no-op once power.config.json exists', regSkip.skipped === true); + fs.rmSync(pacRoot, { recursive: true, force: true }); + + // ── buildAndPush: runs npm run build first when a build script exists, then push ── + const buildPushRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-buildpush-')); + fs.writeFileSync(path.join(buildPushRoot, 'package.json'), JSON.stringify({ name: 'x', scripts: { build: 'node -e "require(\'fs\').writeFileSync(\'built.txt\',\'ok\')"' } })); + const bpLog = []; + const bpPacFake = { pushed: true, output: 'push ok' }; + const bpResult = await pacInit.buildAndPush(buildPushRoot, { + emit: async ({ level, message }) => bpLog.push(`[${level}] ${message}`), + _push: async () => bpPacFake, + }); + check('buildAndPush runs the build script when present', fs.existsSync(path.join(buildPushRoot, 'built.txt'))); + check('buildAndPush reports built:true after a successful build', bpResult.built === true); + check('buildAndPush calls through to push and returns its result', bpResult.pushed === true); + const noBuildRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-buildpush-nobuild-')); + fs.writeFileSync(path.join(noBuildRoot, 'package.json'), JSON.stringify({ name: 'x' })); + const bpNoBuild = await pacInit.buildAndPush(noBuildRoot, { emit: async () => {}, _push: async () => bpPacFake }); + check('buildAndPush skips the build step when no build script exists', bpNoBuild.built === false && bpNoBuild.pushed === true); + const bpThrowRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-buildpush-throw-')); + fs.writeFileSync(path.join(bpThrowRoot, 'package.json'), JSON.stringify({ name: 'x' })); + const bpThrown = await pacInit.buildAndPush(bpThrowRoot, { + emit: async () => {}, + _push: async () => { throw new Error('pac CLI not found or not executable.'); }, + }); + check('buildAndPush never rejects — a thrown push error becomes a returned error', bpThrown.pushed === false && /pac CLI not found/.test(bpThrown.error || '')); + fs.rmSync(buildPushRoot, { recursive: true, force: true }); + fs.rmSync(noBuildRoot, { recursive: true, force: true }); + fs.rmSync(bpThrowRoot, { recursive: true, force: true }); + + // ── datasource.js: pac code add-data-source wrapper ──────────────────────── + const datasourceMod = require('./datasource'); + const dsRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-datasource-')); + const dsFakeRuns = []; + const dsFakePac = { + checkPac: async () => '1.46', + runPac: async (args) => { dsFakeRuns.push(args); return { code: 0, stdout: 'added', stderr: '' }; }, + }; + const dsOk = await datasourceMod.addDataSource(dsRoot, { api: 'dataverse', table: 'cr_invoice', emit: async () => {}, _pac: dsFakePac }); + check('addDataSource succeeds and reports added:true', dsOk.added === true); + check('addDataSource builds -a and -t flags for a Dataverse table', dsFakeRuns[0].join(' ') === ['code', 'add-data-source', '-a', 'dataverse', '-t', 'cr_invoice'].join(' ')); + const dsNoTable = await datasourceMod.addDataSource(dsRoot, { api: 'shared_sharepointonline', emit: async () => {}, _pac: dsFakePac }); + check('addDataSource omits -t for a non-Dataverse connector with no table', !dsFakeRuns[1].includes('-t')); + const dsMissingApi = await datasourceMod.addDataSource(dsRoot, { emit: async () => {}, _pac: dsFakePac }); + check('addDataSource refuses when no api/connector id is given', dsMissingApi.added === false && /api|connector/i.test(dsMissingApi.error || '')); + const dsPacUnreachable = { checkPac: async () => { throw new Error('pac CLI not found or not executable.'); }, runPac: async () => ({ code: 0, stdout: '', stderr: '' }) }; + const dsCheckFail = await datasourceMod.addDataSource(dsRoot, { api: 'dataverse', table: 'cr_invoice', emit: async () => {}, _pac: dsPacUnreachable }); + check('addDataSource returns an error (not a rejection) when pac is unreachable', dsCheckFail.added === false && /pac CLI not found/.test(dsCheckFail.error || '')); + const dsRejects = { checkPac: async () => '1.46', runPac: async () => ({ code: 1, stdout: '', stderr: 'Table logical name not found: cr_bad' }) }; + const dsRunFail = await datasourceMod.addDataSource(dsRoot, { api: 'dataverse', table: 'cr_bad', emit: async () => {}, _pac: dsRejects }); + check('addDataSource reports the CLI error when pac rejects the request', dsRunFail.added === false && /cr_bad/.test(dsRunFail.error || '')); + fs.rmSync(dsRoot, { recursive: true, force: true }); + + // ── Phase 1: live preview (preview.js) — honest-start / honest-degrade ───── + // start() must run a REAL dev server or degrade honestly — never fabricate a URL. + // Inject the spawn + probe boundaries (the `_pac` pattern) so this is deterministic + // and never spawns a real npm/vite process or touches a real port. + const { EventEmitter } = require('node:events'); + const preview = require('./preview'); + // A fake vite process: prints the "Local:" line on the next tick, supports kill(). + const fakeVite = (port) => () => { + const proc = new EventEmitter(); + proc.pid = 4242; + proc.stdout = new EventEmitter(); + proc.stderr = new EventEmitter(); + proc.kill = () => { proc.killed = true; proc.emit('exit', 0); }; + setImmediate(() => proc.stdout.emit('data', Buffer.from(` ➜ Local: http://localhost:${port}/\n`))); + return proc; + }; + const okProbe = async () => true; // resolves ready without touching a real port + + // (a) missing dev script → honest nudge, nothing spawned. + const pvNoDev = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-preview-nodev-')); + fs.mkdirSync(path.join(pvNoDev, 'node_modules'), { recursive: true }); + fs.writeFileSync(path.join(pvNoDev, 'package.json'), JSON.stringify({ scripts: { build: 'vite build' } })); + let spawnedNoDev = false; + const noDevRes = await preview.start(pvNoDev, { _spawn: () => { spawnedNoDev = true; throw new Error('should not spawn'); }, _probe: okProbe }); + check('preview degrades to a plain-language nudge when no dev script exists', noDevRes.ok === false && /dev.*script/i.test(noDevRes.message || '')); + check('preview never spawns a process when it degrades on a missing dev script', spawnedNoDev === false); + fs.rmSync(pvNoDev, { recursive: true, force: true }); + + // (b) successful start via injected fake spawn — parses the port, never fabricates it. + const pvOk = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-preview-ok-')); + fs.mkdirSync(path.join(pvOk, 'node_modules'), { recursive: true }); + fs.writeFileSync(path.join(pvOk, 'package.json'), JSON.stringify({ scripts: { dev: 'vite' } })); + let spawnCount = 0; + const countingVite = (port) => { const mk = fakeVite(port); return (...a) => { spawnCount += 1; return mk(...a); }; }; + const startRes = await preview.start(pvOk, { _spawn: countingVite(6123), _probe: okProbe }); + check('preview start returns the port parsed from vite stdout (not hardcoded)', startRes.url === 'http://localhost:6123' && startRes.pid === 4242); + check('preview status reflects the running server', preview.status(pvOk).running === true && preview.status(pvOk).url === 'http://localhost:6123'); + + // (c) idempotent: a second start() for the same root reuses the server, no new spawn. + const startAgain = await preview.start(pvOk, { _spawn: countingVite(9999), _probe: okProbe }); + check('preview start is idempotent for the same root (reuses, no second spawn)', startAgain.url === 'http://localhost:6123' && spawnCount === 1); + + // (d) stop()/status() reflect reality. + check('preview stop() kills the tracked server', preview.stop(pvOk).stopped === true); + check('preview status is not-running after stop()', preview.status(pvOk).running === false); + check('preview stop() on an unknown root is a safe no-op', preview.stop(pvOk).stopped === false); + fs.rmSync(pvOk, { recursive: true, force: true }); + + // ── Phase 1: live preview — server routes call through to preview.js ────── + // Exercise the real HTTP routes (not the module functions directly) so this + // proves the server wiring, not just preview.js's own contract (already + // covered above). The degrade path needs no injected _spawn/_probe (nothing + // is spawned); the running-state path seeds the module's shared registry via + // a direct preview.start() call with a fake process, then reads it back + // through the HTTP status/stop routes — this is the same shared singleton + // server.js's require('./preview') resolves to, so it's a faithful check. + const pvRouteNoDev = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-preview-route-nodev-')); + fs.mkdirSync(path.join(pvRouteNoDev, 'node_modules'), { recursive: true }); + fs.writeFileSync(path.join(pvRouteNoDev, 'package.json'), JSON.stringify({ scripts: { build: 'vite build' } })); + const pvRoute = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-preview-route-ok-')); + fs.mkdirSync(path.join(pvRoute, 'node_modules'), { recursive: true }); + fs.writeFileSync(path.join(pvRoute, 'package.json'), JSON.stringify({ scripts: { dev: 'vite' } })); + await preview.start(pvRoute, { _spawn: countingVite(7654), _probe: okProbe }); + check('preview module has a running server for pvRoute before hitting routes', preview.status(pvRoute).running === true); + + const routeChecks = await new Promise((resolve) => { + const srv = serve(pvRouteNoDev, { port: 0 }); + srv.on('listening', async () => { + const port = srv.address().port; + try { + const startDegraded = await req(port, 'POST', '/api/preview/start', {}); + srv.close(() => resolve({ startDegraded })); + } catch { + srv.close(() => resolve({})); + } + }); + }); + check('POST /api/preview/start calls through to preview.start() (honest degrade, no dev script)', routeChecks.startDegraded && routeChecks.startDegraded.json.ok === false && /dev.*script/i.test(routeChecks.startDegraded.json.message || '')); + + const routeChecks2 = await new Promise((resolve) => { + const srv = serve(pvRoute, { port: 0 }); + srv.on('listening', async () => { + const port = srv.address().port; + try { + const status1 = await req(port, 'GET', '/api/preview/status'); + const stopped = await req(port, 'POST', '/api/preview/stop', {}); + const status2 = await req(port, 'GET', '/api/preview/status'); + srv.close(() => resolve({ status1, stopped, status2 })); + } catch { + srv.close(() => resolve({})); + } + }); + }); + check('GET /api/preview/status calls through to preview.status() (reflects the running server)', routeChecks2.status1 && routeChecks2.status1.json.running === true && routeChecks2.status1.json.url === 'http://localhost:7654'); + check('POST /api/preview/stop calls through to preview.stop()', routeChecks2.stopped && routeChecks2.stopped.json.stopped === true); + check('status route reflects the stop (not running afterward)', routeChecks2.status2 && routeChecks2.status2.json.running === false); + fs.rmSync(pvRouteNoDev, { recursive: true, force: true }); + fs.rmSync(pvRoute, { recursive: true, force: true }); + + // ── openProject() stops the outgoing project's preview on switch ────────── + // A preview left running for the project being closed must not survive a + // project switch — assert directly against preview.status() (module-level, + // the same registry server.js's openProject() mutates) rather than through + // an HTTP round trip, since the status route only ever reports activeRoot. + const pvA = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-preview-switch-a-')); + const pvB = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-preview-switch-b-')); + fs.mkdirSync(path.join(pvA, 'node_modules'), { recursive: true }); + fs.writeFileSync(path.join(pvA, 'package.json'), JSON.stringify({ scripts: { dev: 'vite' } })); + await preview.start(pvA, { _spawn: countingVite(7655), _probe: okProbe }); + check('preview module has a running server for project A before switching', preview.status(pvA).running === true); + const switchChecks = await new Promise((resolve) => { + const srv = serve(pvA, { port: 0 }); + srv.on('listening', async () => { + const port = srv.address().port; + try { + const opened = await req(port, 'POST', '/api/action', { type: 'open-project', path: pvB }); + srv.close(() => resolve({ opened })); + } catch { + srv.close(() => resolve({})); + } + }); + }); + check('opening project B while A has a live preview succeeds', switchChecks.opened && switchChecks.opened.json.ok === true); + check('switching projects via openProject() stops the outgoing project\'s preview', preview.status(pvA).running === false); + preview.stop(pvB); // safety net in case a future change starts a preview during open-project + fs.rmSync(pvA, { recursive: true, force: true }); + fs.rmSync(pvB, { recursive: true, force: true }); + + // ── Phase 1: on-device preview wiring (loop.js → preview.js) — honest baseUrl ──── + // loop.js's real-mode on-device branch (stage 4, the `!dataverse` path) must call + // preview.start() for a genuine dev-server URL and never fabricate one on failure. + // Tested via the extracted resolveOnDeviceBaseUrl() directly — mirrors how + // pacInit.registerCodeApp is tested directly above (`_pac`) rather than through the + // full loop — so this never spawns a real npm/vite process or touches a real port. + const { resolveOnDeviceBaseUrl } = require('./loop'); + const previewOkEvents = []; + const previewOkUrl = await resolveOnDeviceBaseUrl(root, { + rotation: 1, + emit: async (e) => previewOkEvents.push(e), + _previewStart: async () => ({ url: 'http://localhost:6123', pid: 4242 }), + }); + check('real-mode on-device build calls preview.start and uses its URL as baseUrl', previewOkUrl === 'http://localhost:6123'); + + const previewDegradeEvents = []; + const previewDegradedUrl = await resolveOnDeviceBaseUrl(root, { + rotation: 1, + emit: async (e) => previewDegradeEvents.push(e), + _previewStart: async () => ({ ok: false, message: 'no dev script, so no live preview' }), + }); + check('honest preview degrade leaves baseUrl empty (never fabricated)', previewDegradedUrl === ''); + check('honest preview degrade emits the plain-language message (not swallowed)', previewDegradeEvents.some((e) => e.level === 'warn' && e.message === 'no dev script, so no live preview')); + + // ── agent harness (P1) · godmode + codeapps + craft/verify/change blend ──── + const harness = require('./harness'); + check('harness routes a build request to build mode', harness.route('build a screen to track tasks', 'plan').mode === 'build'); + check('harness routes a bug report to fix mode', harness.route('the save button is broken', 'act').mode === 'fix'); + check('harness routes Dataverse work to the dataverse specialist', harness.route('add a Dataverse table for invoices', 'plan').codeapps === 'dataverse-specialist'); + check('harness routes a connector task to the connector specialist', harness.route('add a SharePoint connector data source to the code app', 'plan').codeapps === 'connector-integrator'); + check('harness flags UI work for the craft router', harness.route('polish the landing page layout and typography', 'act').ui === true); + check('harness flags a runnable surface for verification', harness.route('build a login form screen', 'plan').verify === true); + check('harness leaves a plain question unrouted', harness.route('what is the capital of France', 'answer').mode === 'plain'); + const hOn = { allowHarness: true }; + check('harness composes a non-empty block on a substantive turn', harness.compose({ taskText: 'build a tasks screen', intent: 'plan', rights: hOn }).includes('POWERCODEX HARNESS')); + check('harness skips greetings (chat intent)', harness.compose({ taskText: 'hi there', intent: 'chat', rights: hOn }) === ''); + check('harness injects nothing when the consent flag is off', harness.compose({ taskText: 'build a tasks screen', intent: 'plan', rights: { allowHarness: false } }) === ''); + check('harness fails open when rights are missing (default on)', harness.compose({ taskText: 'build a tasks screen', intent: 'plan', rights: null }).includes('POWERCODEX HARNESS')); + check('harness always carries the ponytail core + guardrails', /leanest|laziest/i.test(harness.compose({ taskText: 'build x', intent: 'plan', rights: hOn })) && /CLAUDE\.md/.test(harness.compose({ taskText: 'build x', intent: 'plan', rights: hOn }))); + check('harness appends the codeapps essence for Power Platform tasks', /dataverse/i.test(harness.compose({ taskText: 'add a Dataverse table', intent: 'plan', rights: hOn }))); + check('harness omits the codeapps block for non-Power-Platform tasks', !/CODEAPPS\//.test(harness.compose({ taskText: 'answer a general question about history', intent: 'answer', rights: hOn }))); + check('harness never throws — always returns a string', typeof harness.compose({}) === 'string' && harness.compose({ taskText: null, intent: undefined }) !== undefined); + check('harness status line names the mode + codeapps skill', /Harness · build/.test(harness.statusLine(harness.route('build a Dataverse app', 'plan')))); + // Wiring: the prompt builders prepend the composed harness at the three agent-facing sites. + const agentMod = require('./agent'); + check('agent-mode prompt includes the harness block', /POWERCODEX HARNESS/.test(agentMod.buildAgentPrompt({ message: 'build a tasks screen', rights: hOn }))); + check('agent-mode prompt omits the harness when disabled', !/POWERCODEX HARNESS/.test(agentMod.buildAgentPrompt({ message: 'build a tasks screen', rights: { allowHarness: false } }))); + const chatMod = require('./chat'); + check('chat prompt includes the harness on a plan turn', /POWERCODEX HARNESS/.test(chatMod.buildPrompt({ system: 'x', message: 'build a tasks screen', intent: 'plan', rights: hOn }))); + check('chat prompt has no harness on a greeting', !/POWERCODEX HARNESS/.test(chatMod.buildPrompt({ system: 'x', message: 'hello', intent: 'chat', rights: hOn }))); + check('harness flag defaults to on in the consent gate', require('./rights').DEFAULTS.allowHarness === true); + + // ── classifyIntent: push / add-datasource / scaffold-project ─────────────── + const { classifyIntent } = require('./chat'); + check('classifyIntent recognizes "push my changes"', classifyIntent('push my changes') === 'push'); + check('classifyIntent recognizes "deploy this"', classifyIntent('deploy this') === 'push'); + check('classifyIntent recognizes "publish to my environment"', classifyIntent('publish to my environment') === 'push'); + check('classifyIntent does not misroute "push back on this design" as push', classifyIntent('push back on this design') !== 'push'); + check('classifyIntent does not misroute "let\'s not deploy yet, I have concerns" as push', classifyIntent("let's not deploy yet, I have concerns") !== 'push'); + check('classifyIntent recognizes "publish this"', classifyIntent('publish this') === 'push'); + check('classifyIntent recognizes "publish it"', classifyIntent('publish it') === 'push'); + check('classifyIntent recognizes "add a datasource for the Orders table"', classifyIntent('add a datasource for the Orders table') === 'add-datasource'); + check('classifyIntent recognizes "wire up a data source"', classifyIntent('wire up a data source') === 'add-datasource'); + check('classifyIntent recognizes "start a new project called Inspections"', classifyIntent('start a new project called Inspections') === 'scaffold-project'); + check('classifyIntent recognizes "create a new powercodex project"', classifyIntent('create a new powercodex project') === 'scaffold-project'); + check('classifyIntent does not misroute "create a dashboard for the project" as scaffold-project', classifyIntent('create a dashboard for the project') !== 'scaffold-project'); + check('classifyIntent does not misroute "make a chart of project progress" as scaffold-project', classifyIntent('make a chart of project progress') !== 'scaffold-project'); + check('classifyIntent does not misroute "set up a status screen for this project" as scaffold-project', classifyIntent('set up a status screen for this project') !== 'scaffold-project'); + check('classifyIntent leaves an unrelated build ask as plan', classifyIntent('build a screen to track tasks') === 'plan'); + check('classifyIntent leaves "fix it" as act', classifyIntent('fix it') === 'act'); + + // ── agent.run(): push / add-datasource execute inline; scaffold-project defers ── + const agentRunRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'powercodex-agent-run-')); + fs.writeFileSync(path.join(agentRunRoot, 'package.json'), JSON.stringify({ name: 'x' })); + require('./rights').ensureRights(agentRunRoot, { allowPush: true }); + const agentPushEvents = []; + const agentPushResult = await agentMod.run(agentRunRoot, { + message: 'push my changes', + emit: (e) => agentPushEvents.push(e), + _pushFn: async () => ({ pushed: true, built: false, output: 'ok' }), + }); + check('agent push intent executes inline and reports kind:push', agentPushResult.kind === 'push' && agentPushResult.ok === true); + check('agent push intent streams progress onto the bus', agentPushEvents.length > 0); + const agentDsResult = await agentMod.run(agentRunRoot, { + message: 'add a datasource for the Orders table', + emit: () => {}, + _addDataSourceFn: async () => ({ added: true, output: 'ok' }), + }); + check('agent add-datasource intent executes inline and reports kind:add-datasource', agentDsResult.kind === 'add-datasource' && agentDsResult.ok === true); + let agentDsQuotedTable; + const agentDsQuotedResult = await agentMod.run(agentRunRoot, { + message: 'add a datasource for "Orders" table', + emit: () => {}, + _addDataSourceFn: async (root, opts) => { agentDsQuotedTable = opts.table; return { added: true, output: 'ok' }; }, + }); + check('agent add-datasource intent extracts a table name from straight-quoted phrasing', agentDsQuotedTable === 'Orders'); + const agentScaffoldResult = await agentMod.run(agentRunRoot, { message: 'start a new project called Inspections', emit: () => {} }); + check('agent scaffold-project intent defers to the server with the extracted name', agentScaffoldResult.kind === 'scaffold-project' && agentScaffoldResult.name === 'Inspections'); + const agentScaffoldQuoted = await agentMod.run(agentRunRoot, { message: 'start a new project called "Inspections"', emit: () => {} }); + check('agent scaffold-project intent extracts a name from straight-quoted phrasing', agentScaffoldQuoted.kind === 'scaffold-project' && agentScaffoldQuoted.name === 'Inspections'); + const agentScaffoldNoName = await agentMod.run(agentRunRoot, { message: 'start a new project', emit: () => {} }); + check('agent scaffold-project asks for a name when none is given', agentScaffoldNoName.kind === 'answer' && /name/i.test(agentScaffoldNoName.reply || '')); + fs.rmSync(agentRunRoot, { recursive: true, force: true }); + + // ── Phase 1: live preview — Canvas UI (chat.html) carries the Preview|Code toggle ── + // UI-only assets can't be driven headless from here (that is task 1.6's real-browser + // smoke test); assert the toggle markup + the preview-specific loader exist, and that + // the vendored starter copy (which ships in every generated project) stays in lockstep + // with the engine copy. The starter path only resolves in the engine repo, so skip it + // when running from inside a generated project. + const chatHtmlPaths = [ + path.join(__dirname, '..', 'assets', 'chat.html'), + path.join(__dirname, '..', '..', '..', 'templates', 'starter', 'tools', 'lifecycle', 'assets', 'chat.html'), + ]; + for (const [i, p] of chatHtmlPaths.entries()) { + if (i === 1 && !fs.existsSync(p)) continue; // vendored starter only exists in the engine repo + const label = i === 0 ? 'engine' : 'vendored starter'; + const html = fs.readFileSync(p, 'utf8'); + check(`canvas has a Preview|Code toggle (${label})`, /id="cvPreview"/.test(html) && /id="cvCode"/.test(html)); + check(`canvas preview tab has a device-width toggle + open-in-browser (${label})`, /id="cvOpenBrowser"/.test(html) && /class="dev"/.test(html)); + check(`canvas has a preview loader separate from showUrlInCanvas, wired to the preview routes (${label})`, /function setPreviewFrame/.test(html) && /api\/preview\/start/.test(html) && /api\/preview\/status/.test(html)); + check(`preview loader keeps a localhost-only URL guard (rejects javascript:/data:) (${label})`, /function safePreviewUrl/.test(html) && html.includes('localhost):')); + check(`toolbar has a Push button gated on allowPush (${label})`, /id="pushBtn"/.test(html) && html.includes("rights.allowPush")); + check(`toolbar has an Add datasource button (${label})`, /id="datasourceBtn"/.test(html)); + check(`Add-datasource panel lists Dataverse tables from /api/dataverse-state (${label})`, /api\/dataverse-state/.test(html) && /id="dsPanel"/.test(html)); + check(`there is a Create new project entry point calling scaffold-project (${label})`, /id="newProjectBtn"/.test(html) && html.includes("'scaffold-project'")); + const scriptMatch = html.match(/