@selvakumaresra/specship 0.3.0 → 0.4.0

package/dist/designer/artifact-store.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionDir = sessionDir;
+exports.saveIteration = saveIteration;
+exports.artifactsRoot = artifactsRoot;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const repo_root_1 = require("./repo-root");
+const ARTIFACTS_ROOT = process.env.DESIGNER_ARTIFACTS_DIR || node_path_1.default.join(repo_root_1.REPO_ROOT, 'artifacts');
+function slug(s) {
+    return String(s || 'session')
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 64) || 'session';
+}
+function ts() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}
+function sessionDir(key) {
+    const dir = node_path_1.default.join(ARTIFACTS_ROOT, slug(key));
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function saveIteration(key, input) {
+    const dir = sessionDir(key);
+    const stamp = ts();
+    const base = node_path_1.default.join(dir, stamp);
+    const record = {
+        at: new Date().toISOString(),
+        key,
+        prompt: input.prompt,
+        fidelity: input.fidelity,
+        url: input.url,
+        meta: input.meta ?? null,
+        files: {}
+    };
+    if (input.html) {
+        const p = `${base}.html`;
+        node_fs_1.default.writeFileSync(p, input.html);
+        record.files.html = p;
+    }
+    if (input.screenshotPath) {
+        record.files.screenshot = input.screenshotPath;
+    }
+    node_fs_1.default.writeFileSync(`${base}.json`, JSON.stringify(record, null, 2));
+    return record;
+}
+function artifactsRoot() {
+    return ARTIFACTS_ROOT;
+}

package/dist/designer/browser.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrowser = createBrowser;
+const cross_platform_1 = require("./cross-platform");
+const BIN = process.env.DESIGNER_AGENT_BROWSER_BIN || 'agent-browser';
+const DEFAULT_SESSION = process.env.DESIGNER_SESSION_NAME || 'designer';
+// Default to the dedicated debug Chrome on :9222. Without this, callers that
+// don't export DESIGNER_CDP (e.g. codex shelling `designer` directly) silently
+// fall through to AGENT_BROWSER_SESSION_NAME mode and agent-browser launches
+// its own Chromium instead of attaching to the user's live signed-in Chrome.
+// Set DESIGNER_CDP='' explicitly to opt out and use the session-managed flow.
+const CDP = process.env.DESIGNER_CDP ?? '9222';
+function createBrowser({ session = DEFAULT_SESSION, headed = true, timeoutMs = 30_000, cdp = CDP } = {}) {
+    const baseEnv = {
+        ...process.env,
+        AGENT_BROWSER_DEFAULT_TIMEOUT: String(timeoutMs),
+        ...(cdp ? {} : { AGENT_BROWSER_SESSION_NAME: session }),
+        ...(headed && !cdp ? { AGENT_BROWSER_HEADED: '1' } : {})
+    };
+    function connectFlags() {
+        if (!cdp)
+            return [];
+        // agent-browser's daemon honors --cdp only when it first creates a
+        // session; an existing session keeps its original connection and
+        // silently ignores a different --cdp endpoint (verified on 0.21.4
+        // through 0.27.2). Scope the daemon session by endpoint so designer
+        // never inherits a connection to some other Chrome — e.g. the user's
+        // own agent-browser use against a different port (issue #32 triage).
+        const scope = ['--session', `designer-cdp-${cdp.replace(/[^a-zA-Z0-9.-]/g, '_')}`];
+        if (cdp === 'auto' || cdp === '1' || cdp === 'true')
+            return [...scope, '--auto-connect'];
+        return [...scope, '--cdp', cdp];
+    }
+    function run(args, { input, parseJson = false } = {}) {
+        return new Promise((resolve, reject) => {
+            const finalArgs = [...connectFlags(), ...args];
+            const child = (0, cross_platform_1.xspawn)(BIN, finalArgs, { env: baseEnv, stdio: ['pipe', 'pipe', 'pipe'] });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (d) => (stdout += d.toString()));
+            child.stderr.on('data', (d) => (stderr += d.toString()));
+            child.on('error', (err) => reject(err));
+            child.on('close', (code) => {
+                if (code !== 0) {
+                    const err = new Error(`agent-browser ${finalArgs.join(' ')} exited ${code}: ${stderr.trim() || stdout.trim()}`);
+                    err.code = code;
+                    return reject(err);
+                }
+                if (!parseJson)
+                    return resolve(stdout.trim());
+                try {
+                    resolve(JSON.parse(stdout));
+                }
+                catch (e) {
+                    reject(new Error(`Failed to parse JSON from agent-browser: ${e.message}\n--stdout--\n${stdout}`));
+                }
+            });
+            if (input != null) {
+                child.stdin.write(input);
+                child.stdin.end();
+            }
+        });
+    }
+    return {
+        session,
+        run,
+        open: (url) => run(['open', url]),
+        close: () => run(['close']).catch(() => null),
+        url: () => run(['get', 'url']),
+        title: () => run(['get', 'title']),
+        tabs: async () => {
+            const out = await run(['tab', 'list', '--json']);
+            const env = JSON.parse(out);
+            if (env.success === false) {
+                throw new Error(`agent-browser tab list failed: ${JSON.stringify(env.error)}`);
+            }
+            return env.data?.tabs ?? [];
+        },
+        activateTab: async (index) => {
+            await run(['tab', String(index)]);
+        },
+        reload: () => run(['reload']),
+        cookies: async () => {
+            const out = await run(['cookies', 'get', '--json']);
+            const env = JSON.parse(out);
+            if (env.success === false) {
+                throw new Error(`agent-browser cookies get failed: ${JSON.stringify(env.error)}`);
+            }
+            return env.data?.cookies ?? [];
+        },
+        snapshot: ({ interactive = true, scope } = {}) => {
+            const args = ['snapshot', '--json'];
+            if (interactive)
+                args.push('-i');
+            if (scope)
+                args.push('-s', scope);
+            return run(args, { parseJson: true });
+        },
+        snapshotText: ({ interactive = true, scope } = {}) => {
+            const args = ['snapshot'];
+            if (interactive)
+                args.push('-i');
+            if (scope)
+                args.push('-s', scope);
+            return run(args);
+        },
+        click: (sel) => run(['click', sel]),
+        fill: (sel, text) => run(['fill', sel, text]),
+        type: (sel, text) => run(['type', sel, text]),
+        press: (key) => run(['press', key]),
+        getText: (sel) => run(['get', 'text', sel]),
+        getAttr: (sel, name) => run(['get', 'attr', name, sel]),
+        getHtml: (sel) => run(['get', 'html', sel]),
+        isVisible: (sel) => run(['is', 'visible', sel]).then((s) => s.trim() === 'true'),
+        waitFor: (selOrMs) => run(['wait', String(selOrMs)]),
+        waitLoad: (state = 'networkidle') => run(['wait', '--load', state]),
+        screenshot: (path, { full = false } = {}) => {
+            const args = ['screenshot'];
+            if (path)
+                args.push(path);
+            if (full)
+                args.push('--full');
+            return run(args);
+        },
+        // Pipe JS via stdin (agent-browser's `--stdin` flag) instead of argv.
+        // Argv-passed JS gets mangled by every shell layer (parens, quotes,
+        // newlines all suffer) — most painfully on Windows where cmd.exe
+        // doesn't preserve multiline strings — but this is the correct cross-
+        // platform path: no escaping required, JS goes through verbatim.
+        eval: (js) => run(['eval', '--stdin'], { input: js }),
+        evalValue: async (js) => {
+            const out = await run(['eval', '--stdin'], { input: js });
+            try {
+                return JSON.parse(out);
+            }
+            catch (e) {
+                throw new Error(`evalValue: stdout was not JSON-parseable: ${e.message}\n--stdout--\n${out.slice(0, 500)}`);
+            }
+        }
+    };
+}

package/dist/designer/cdp-ensure.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureCdpUp = ensureCdpUp;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const cross_platform_1 = require("./cross-platform");
+const cdp_env_1 = require("./cdp-env");
+const PORT = process.env.DESIGNER_CDP || '9222';
+const PROFILE = node_path_1.default.join(node_os_1.default.homedir(), '.chrome-designer-profile');
+const CHROME_BIN = process.env.CHROME_BIN || (0, cross_platform_1.defaultChromeBin)();
+async function isCdpUp() {
+    try {
+        const res = await fetch(`http://127.0.0.1:${PORT}/json/version`, { signal: AbortSignal.timeout(1500) });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+// Make sure a debug Chrome is listening on CDP before the first tool call.
+// Auto-launch is gated on three conditions:
+//   1. CDP is down (no existing debug server)
+//   2. The dedicated profile exists (user already consented once via `designer setup`)
+//   3. No non-debug Chrome is running (launching would either no-op or steal focus)
+// Otherwise: return an actionable error the caller can surface to the user.
+async function ensureCdpUp() {
+    // Respect the explicit opt-out (DESIGNER_CDP=''): never probe or auto-launch
+    // the debug Chrome for a user who chose the agent-browser session-managed flow.
+    // Throwing here makes any stray CdpSession.attach() degrade to null cleanly.
+    if (!(0, cdp_env_1.isCdpEnabled)()) {
+        throw new Error("CDP explicitly disabled (DESIGNER_CDP=''); using the agent-browser session-managed flow.");
+    }
+    if (await isCdpUp())
+        return;
+    if (!node_fs_1.default.existsSync(PROFILE)) {
+        throw new Error(`CDP not up on :${PORT} and no dedicated Chrome profile at ${PROFILE}. Run: designer setup`);
+    }
+    if ((0, cross_platform_1.isChromeRunning)()) {
+        throw new Error(`CDP not up on :${PORT} and a non-debug Chrome is already running. ${cross_platform_1.QUIT_CHROME_HINT} Then retry, or run: designer setup`);
+    }
+    if (!node_fs_1.default.existsSync(CHROME_BIN)) {
+        throw new Error(`CDP not up on :${PORT} and Chrome not found at ${CHROME_BIN}. Set CHROME_BIN or install Chrome.`);
+    }
+    const child = (0, node_child_process_1.spawn)(CHROME_BIN, ['--remote-debugging-port=' + PORT, '--user-data-dir=' + PROFILE, 'https://claude.ai/design'], { detached: true, stdio: 'ignore' });
+    child.unref();
+    for (let i = 0; i < 40; i++) {
+        await sleep(500);
+        if (await isCdpUp())
+            return;
+    }
+    throw new Error(`Auto-launched Chrome but CDP didn't come up on :${PORT} within 20s. Check that the launched window survived, or run designer setup.`);
+}

package/dist/designer/cdp-env.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCdpEnabled = isCdpEnabled;
+// Shared resolution of the DESIGNER_CDP opt-out.
+//
+// DESIGNER_CDP has THREE states (see CLAUDE.md): unset or '9222' = CDP on,
+// '' = OFF (the agent-browser session-managed flow). The opt-out is enforced at
+// the GATES (controller attach, the turn-RPC canary, ensureCdpUp), not in the
+// port constants — `browser.ts` resolves the port with `??` (honors '') while
+// `cdp-trace.ts`/`cdp-ensure.ts` use `|| '9222'` (do NOT honor ''), by design.
+//
+// This is the single definition of "is CDP work allowed", so the load-bearing
+// gate can't drift across its call sites (it was inlined in designer-controller
+// 4× and, inverted, in ui-anchors). Pure, no I/O — reads the env at call time so
+// a test or runtime toggle is honored.
+function isCdpEnabled() {
+    return (process.env.DESIGNER_CDP ?? '9222') !== '';
+}