@webstew/bridge 0.1.0

package/dist/cli.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+"use strict";
+// @webstew/bridge CLI entry. Registered as `bin` so users run
+//
+// Shebang note: we point to `tsx` (TypeScript loader for Node) so the
+// raw .ts files in src/ can be executed without a build step during
+// monorepo dev + initial install. When we cut a real npm release we'll
+// compile to dist/ and the published shebang will go back to plain
+// `#!/usr/bin/env node`. `env -S` is needed on macOS so env passes the
+// multi-arg command intact.
+// `npx @webstew/bridge <subcommand>` (or `webstew-bridge` if installed
+// globally) without a node-modules dance.
+//
+// Subcommands:
+//   connect <code>       pair with a Webstew workspace, then start the bridge
+//   status               print connection state from local config
+//   logout               forget the saved pairing token
+//   --help, -h           print usage
+//   --version, -v        print bridge + protocol versions
+//
+// Persistent auth lives at ~/.webstew/bridge.json (0600 perms). See
+// auth.ts. The CLI does NOT manage Claude Code's OAuth — that's owned
+// by Claude Code itself; the bridge just spawns `claude --print …` and
+// inherits whatever auth Claude Code is using.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_os_1 = __importDefault(require("node:os"));
+const protocol_1 = require("./protocol");
+const auth_1 = require("./auth");
+const runtime_1 = require("./runtime");
+const BRIDGE_VERSION = (() => {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return require('../package.json').version;
+    }
+    catch {
+        return '0.0.0-dev';
+    }
+})();
+const DEFAULT_SERVER_URL = process.env.WEBSTEW_SERVER_URL || 'https://webstew.net';
+const HELP = `webstew-bridge — your kitchen line to Webstew. Cooks every order on
+your installed Claude Code so your Pro/Max subscription picks up the tab.
+
+Usage:
+  webstew-bridge connect            Resume using saved session (after restarts).
+  webstew-bridge connect <code>    Hire the chef. Get the code from
+                                   /integrations → "Connect Local Bridge".
+  webstew-bridge status            Peek at the pass.
+  webstew-bridge logout            Hang up the apron.
+  webstew-bridge --help            This menu.
+  webstew-bridge --version         Bridge + protocol versions.
+
+Environment:
+  WEBSTEW_SERVER_URL   Override the server URL (defaults to https://webstew.net).
+                       Set to http://localhost:3000 to pair with a local dev workspace.
+
+Keep this terminal open — that's the kitchen. Send orders from your
+Webstew workspace and the chef cooks them on your subscription.
+`;
+function log(msg) {
+    const ts = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    process.stdout.write(`[${ts}] ${msg}\n`);
+}
+async function cmdConnect(code) {
+    // No code supplied — try to resume using stored token (survives dev-server restarts).
+    if (!code) {
+        const existing = (0, auth_1.loadAuth)();
+        if (!existing) {
+            process.stderr.write('error: no pairing code and no stored session.\n  usage: webstew-bridge connect <code>\n  Get a code from /integrations → "Connect Local Bridge".\n');
+            return 2;
+        }
+        log(`resuming session bridgeId=${existing.bridgeId} — no new code needed`);
+        await (0, runtime_1.startBridge)({ ctx: { serverUrl: existing.serverUrl, pairingToken: existing.pairingToken }, log });
+        return 0;
+    }
+    // Exchange the code for a long-lived pairingToken via /api/bridge/pair.
+    log(`pairing with ${DEFAULT_SERVER_URL}…`);
+    const body = {
+        code,
+        hostname: node_os_1.default.hostname() || 'unknown',
+        bridgeVersion: BRIDGE_VERSION,
+        protocolVersion: protocol_1.PROTOCOL_VERSION,
+    };
+    let res;
+    try {
+        res = await fetch(DEFAULT_SERVER_URL.replace(/\/$/, '') + protocol_1.BRIDGE_ROUTES.pairExchange, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (e) {
+        process.stderr.write(`error: cannot reach ${DEFAULT_SERVER_URL}: ${e.message}\n`);
+        return 1;
+    }
+    if (!res.ok) {
+        let detail = '';
+        try {
+            detail = (await res.json())?.error || '';
+        }
+        catch { }
+        process.stderr.write(`error: pairing failed (HTTP ${res.status}): ${detail || 'no details'}\n`);
+        return 1;
+    }
+    const out = (await res.json());
+    (0, auth_1.saveAuth)({
+        serverUrl: DEFAULT_SERVER_URL,
+        bridgeId: out.bridgeId,
+        pairingToken: out.pairingToken,
+        pairedAt: new Date().toISOString(),
+    });
+    log(`paired ✓  bridgeId=${out.bridgeId}`);
+    log(`chef hired — keep this terminal open, the kitchen needs the line`);
+    // Start the long-poll loop. Never returns.
+    await (0, runtime_1.startBridge)({
+        ctx: { serverUrl: DEFAULT_SERVER_URL, pairingToken: out.pairingToken },
+        log,
+    });
+    return 0;
+}
+async function cmdStatus() {
+    const auth = (0, auth_1.loadAuth)();
+    if (!auth) {
+        process.stdout.write('not paired. Run: webstew-bridge connect <code>\n');
+        return 0;
+    }
+    process.stdout.write(`paired with ${auth.serverUrl}\n` +
+        `  bridgeId:   ${auth.bridgeId}\n` +
+        `  paired at:  ${auth.pairedAt}\n` +
+        `\nrun \`webstew-bridge connect\` to resume (no code needed).\n`);
+    return 0;
+}
+function cmdLogout() {
+    const removed = (0, auth_1.clearAuth)();
+    process.stdout.write(removed ? 'pairing token removed\n' : 'no pairing token to remove\n');
+    return 0;
+}
+async function main(argv) {
+    const [, , sub, ...rest] = argv;
+    if (!sub || sub === '--help' || sub === '-h' || sub === 'help') {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    if (sub === '--version' || sub === '-v' || sub === 'version') {
+        process.stdout.write(`@webstew/bridge ${BRIDGE_VERSION} (protocol ${protocol_1.PROTOCOL_VERSION})\n`);
+        return 0;
+    }
+    if (sub === 'connect')
+        return cmdConnect(rest[0] || '');
+    if (sub === 'status')
+        return cmdStatus();
+    if (sub === 'logout')
+        return cmdLogout();
+    process.stderr.write(`error: unknown subcommand "${sub}"\n\n${HELP}`);
+    return 2;
+}
+main(process.argv).then((code) => process.exit(code), (err) => {
+    process.stderr.write(`bridge fatal: ${err?.stack || err}\n`);
+    process.exit(1);
+});

package/dist/http.d.ts

@@ -0,0 +1,14 @@
+export declare class HttpError extends Error {
+    status: number;
+    body?: unknown | undefined;
+    constructor(status: number, message: string, body?: unknown | undefined);
+}
+export interface HttpContext {
+    serverUrl: string;
+    pairingToken: string;
+}
+export declare function pollOnce<T>(ctx: HttpContext, signal?: AbortSignal): Promise<T>;
+export declare function postResponse(ctx: HttpContext, body: unknown): Promise<{
+    accepted: boolean;
+}>;
+export declare function postHeartbeat(ctx: HttpContext): Promise<void>;

package/dist/http.js

@@ -0,0 +1,56 @@
+"use strict";
+// Thin fetch wrapper. Just enough to: (a) attach the bearer token, (b)
+// retry transient network errors on poll/heartbeat without giving up,
+// (c) surface server errors with readable messages. Uses Node 18+
+// built-in fetch — no node-fetch dep.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpError = void 0;
+exports.pollOnce = pollOnce;
+exports.postResponse = postResponse;
+exports.postHeartbeat = postHeartbeat;
+const protocol_1 = require("./protocol");
+class HttpError extends Error {
+    status;
+    body;
+    constructor(status, message, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+    }
+}
+exports.HttpError = HttpError;
+async function call(ctx, method, pathStr, body, init) {
+    const url = ctx.serverUrl.replace(/\/$/, '') + pathStr;
+    const headers = {
+        Authorization: `Bearer ${ctx.pairingToken}`,
+        'x-webstew-bridge-protocol': protocol_1.PROTOCOL_VERSION,
+    };
+    if (body !== undefined)
+        headers['Content-Type'] = 'application/json';
+    const res = await fetch(url, {
+        method,
+        headers,
+        body: body === undefined ? undefined : JSON.stringify(body),
+        ...init,
+    });
+    if (!res.ok) {
+        let parsed;
+        try {
+            parsed = await res.json();
+        }
+        catch { }
+        throw new HttpError(res.status, parsed?.error || `${method} ${pathStr} → HTTP ${res.status}`, parsed);
+    }
+    // Some endpoints (poll) may return null body via {empty:true}; parse
+    // JSON unconditionally — server always returns JSON.
+    return (await res.json());
+}
+async function pollOnce(ctx, signal) {
+    return call(ctx, 'GET', protocol_1.BRIDGE_ROUTES.poll, undefined, { signal });
+}
+async function postResponse(ctx, body) {
+    return call(ctx, 'POST', protocol_1.BRIDGE_ROUTES.respond, body);
+}
+async function postHeartbeat(ctx) {
+    await call(ctx, 'POST', protocol_1.BRIDGE_ROUTES.heartbeat, {});
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './protocol';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// Public surface of @webstew/bridge. Webstew's app imports from here to
+// get the protocol types; standalone bridge users get the same types if
+// they want to script around the CLI.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./protocol"), exports);

package/dist/protocol.d.ts

@@ -0,0 +1,151 @@
+export declare const PROTOCOL_VERSION = "1.0.0";
+export declare const POLL_TIMEOUT_MS = 25000;
+export declare const HEARTBEAT_INTERVAL_MS = 15000;
+export declare const BRIDGE_OFFLINE_AFTER_MS = 60000;
+export interface PairingCodeResponse {
+    /** Short human-friendly code the user pastes into the CLI. */
+    code: string;
+    /** Seconds until the code expires (typically 600). */
+    expiresInSec: number;
+    /** Origin the bridge should connect to (e.g. https://webstew.net). */
+    serverUrl: string;
+}
+export interface PairingExchangeRequest {
+    code: string;
+    /** Free-form label so users can tell bridges apart in the UI. */
+    hostname: string;
+    bridgeVersion: string;
+    protocolVersion: string;
+}
+export interface PairingExchangeResponse {
+    /** Long-lived auth token. Bridge sends as `Authorization: Bearer …`. */
+    pairingToken: string;
+    /** Server-assigned ID for this bridge — surfaces in UI + logs. */
+    bridgeId: string;
+}
+export interface BridgeStatus {
+    connected: boolean;
+    /** ISO timestamp of the bridge's last poll/heartbeat. */
+    lastSeenAt?: string;
+    bridgeId?: string;
+    hostname?: string;
+    bridgeVersion?: string;
+    /** Number of in-flight agent requests currently queued or running. */
+    inFlightRequests: number;
+}
+export type BridgeRequest = {
+    kind: 'agent.run';
+    requestId: string;
+    payload: AgentRunRequest;
+};
+export interface AgentRunRequest {
+    prompt: string;
+    /** Project VFS snapshot — same shape the existing /api/builder/agent
+     *  route accepts. Bridge replays edits against this map. */
+    files: Record<string, string>;
+    history?: Array<{
+        role: 'user' | 'assistant';
+        content: any;
+    }>;
+    /** 'claude-opus-4-7' | 'claude-sonnet-4-6' | 'claude-haiku-4-5-…' —
+     *  bridge maps to the local CLI's --model flag. Empty = bridge picks
+     *  its default. */
+    model?: string;
+    target?: 'website' | 'nextjs' | 'react' | 'astro' | 'expo';
+    /** Webstew project id — bridge echoes back on file_update events so
+     *  the server can persist the same way it does for direct Anthropic. */
+    projectId?: string;
+    /** Cap on tool-use iterations. Server passes the agent route's
+     *  configured limit so bridge enforcement matches direct flow. */
+    maxIterations?: number;
+}
+export type BridgeResponse = {
+    requestId: string;
+    kind: 'text';
+    data: {
+        text: string;
+    };
+} | {
+    requestId: string;
+    kind: 'tool_use';
+    data: {
+        id: string;
+        name: string;
+        input: any;
+    };
+} | {
+    requestId: string;
+    kind: 'tool_result';
+    data: {
+        tool_use_id: string;
+        ok: boolean;
+        content: string;
+    };
+} | {
+    requestId: string;
+    kind: 'file_update';
+    data: {
+        path: string;
+        contents: string;
+    };
+} | {
+    requestId: string;
+    kind: 'file_delete';
+    data: {
+        path: string;
+    };
+} | {
+    requestId: string;
+    kind: 'done';
+    data: {
+        summary: string;
+        iterations: number;
+    };
+} | {
+    requestId: string;
+    kind: 'error';
+    data: {
+        message: string;
+    };
+} | {
+    requestId: string;
+    kind: 'workspace.switch_target';
+    data: {
+        target: string;
+        reason: string;
+    };
+} | {
+    requestId: string;
+    kind: 'workspace.open_panel';
+    data: {
+        panel: string;
+        reason: string;
+    };
+} | {
+    requestId: string;
+    kind: 'permission_request';
+    data: {
+        permissionId: string;
+        action: string;
+        title: string;
+        description: string;
+        approveLabel?: string;
+        denyLabel?: string;
+        meta?: Record<string, unknown>;
+    };
+};
+export declare const BRIDGE_ROUTES: {
+    readonly pairInit: "/api/bridge/pair-init";
+    readonly pairExchange: "/api/bridge/pair";
+    readonly poll: "/api/bridge/poll";
+    readonly respond: "/api/bridge/respond";
+    readonly heartbeat: "/api/bridge/heartbeat";
+    readonly status: "/api/bridge/status";
+    readonly disconnect: "/api/bridge/disconnect";
+};
+/** Polled when the queue is empty. Distinct from `null` so the bridge
+ *  can re-poll immediately without ambiguity around timeouts. */
+export interface EmptyPoll {
+    empty: true;
+}
+export type PollResponse = BridgeRequest | EmptyPoll;

package/dist/protocol.js

@@ -0,0 +1,50 @@
+"use strict";
+// Wire protocol shared by the Webstew server and the @webstew/bridge CLI.
+// Both sides import these types so any change to the contract is a
+// compile-time break. Keep this file deps-free (pure types + tiny consts)
+// so the bridge CLI bundle stays under ~50KB.
+//
+// Lifecycle of one agent turn:
+//   1. User submits chat in /workspace → POST /api/builder/agent on Webstew.
+//   2. Webstew detects the user has an active bridge (per BridgeStatus) and
+//      enqueues a BridgeRequest in the per-user queue instead of calling
+//      Anthropic directly. The HTTP handler holds the response open (SSE).
+//   3. The local bridge process is long-polling GET /api/bridge/poll; it
+//      receives the BridgeRequest within a few hundred ms.
+//   4. Bridge spawns Claude Agent SDK (or `claude -p`) using the user's
+//      already-authenticated local OAuth — this is the whole point: their
+//      Pro/Max subscription, not API-rate billing.
+//   5. As the agent streams, bridge POSTs each chunk to
+//      /api/bridge/respond as a BridgeResponse. Webstew forwards each
+//      chunk straight to the waiting SSE consumer (the workspace chat).
+//   6. Bridge sends a `done` (or `error`) BridgeResponse to close.
+//
+// Versioning: this is v1. Breaking changes bump PROTOCOL_VERSION; the
+// server rejects bridges on an older major version with a clear error
+// telling the user to `npm i -g @webstew/bridge@latest`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRIDGE_ROUTES = exports.BRIDGE_OFFLINE_AFTER_MS = exports.HEARTBEAT_INTERVAL_MS = exports.POLL_TIMEOUT_MS = exports.PROTOCOL_VERSION = void 0;
+exports.PROTOCOL_VERSION = '1.0.0';
+// How long the bridge holds a poll open before returning empty so it can
+// re-issue. Tuned for: (a) Render's default 30s edge timeout, (b) fast
+// reconnect after server restarts. 25s gives 5s headroom under Render's
+// limit. Bridge should re-poll immediately on empty return.
+exports.POLL_TIMEOUT_MS = 25_000;
+// How often the bridge sends a tiny heartbeat ping while idle, so the
+// server knows the connection is live. Drives BridgeStatus.lastSeen.
+exports.HEARTBEAT_INTERVAL_MS = 15_000;
+// Server treats a bridge as offline if no poll/heartbeat in this long.
+// Generous so brief network blips don't flap the UI status.
+exports.BRIDGE_OFFLINE_AFTER_MS = 60_000;
+// ── HTTP shapes ───────────────────────────────────────────────────────
+// Concrete endpoint paths. Centralized so both sides import the same
+// strings; typos become impossible.
+exports.BRIDGE_ROUTES = {
+    pairInit: '/api/bridge/pair-init', // user → server, requires session
+    pairExchange: '/api/bridge/pair', // bridge → server, body: PairingExchangeRequest
+    poll: '/api/bridge/poll', // bridge → server, long-poll, returns BridgeRequest | null
+    respond: '/api/bridge/respond', // bridge → server, body: BridgeResponse
+    heartbeat: '/api/bridge/heartbeat', // bridge → server, idle keepalive
+    status: '/api/bridge/status', // UI → server, requires session
+    disconnect: '/api/bridge/disconnect', // UI → server, revokes token
+};

package/dist/runtime.d.ts

@@ -0,0 +1,7 @@
+import { HttpContext } from './http';
+interface RunOpts {
+    ctx: HttpContext;
+    log: (msg: string) => void;
+}
+export declare function startBridge(opts: RunOpts): Promise<never>;
+export {};

package/dist/runtime.js

@@ -0,0 +1,113 @@
+"use strict";
+// Bridge runtime — the main loop after `connect` succeeds.
+//
+// Two concurrent activities:
+//   1. Long-poll for work: hit /api/bridge/poll, on receiving a request
+//      dispatch it to the claude runner, stream events back via
+//      /api/bridge/respond. On empty, re-poll immediately.
+//   2. Heartbeat: every HEARTBEAT_INTERVAL_MS while we're not in the
+//      middle of an active long-poll, POST /api/bridge/heartbeat to
+//      keep BridgeStatus.lastSeenAt fresh on the server.
+//
+// Concurrency: we process ONE request at a time per bridge (sequential
+// poll → run → respond → poll). A Claude run can take 30-120s; running
+// two in parallel would race the local Claude Code session. If a user
+// needs parallel runs they can run multiple bridges.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startBridge = startBridge;
+const http_1 = require("./http");
+const protocol_1 = require("./protocol");
+const claude_runner_1 = require("./claude-runner");
+async function startBridge(opts) {
+    const { ctx, log } = opts;
+    log('kitchen open — waiting for orders 🥘');
+    // Heartbeat in a separate tick so it doesn't compete with polls.
+    // Errors are non-fatal — server's authenticate* already touches
+    // lastSeenAt on every poll, so missed heartbeats are cosmetic.
+    let lastHeartbeatAt = Date.now();
+    const heartbeatTick = setInterval(() => {
+        if (Date.now() - lastHeartbeatAt < protocol_1.HEARTBEAT_INTERVAL_MS)
+            return;
+        (0, http_1.postHeartbeat)(ctx).catch(() => { }).finally(() => {
+            lastHeartbeatAt = Date.now();
+        });
+    }, 5_000);
+    // Main long-poll loop. Never returns.
+    for (;;) {
+        let work;
+        try {
+            work = await (0, http_1.pollOnce)(ctx);
+            lastHeartbeatAt = Date.now(); // poll counts as activity
+        }
+        catch (e) {
+            if (e instanceof http_1.HttpError && e.status === 401) {
+                clearInterval(heartbeatTick);
+                log(`apron revoked (${e.message}). The kitchen disconnected this chef from the floor. Re-pair to get back on the line.`);
+                process.exit(2);
+            }
+            // Transient network blip — back off briefly and retry.
+            log(`waiter call dropped: ${e.message} — reaching back in 3s`);
+            await sleep(3_000);
+            continue;
+        }
+        if ('empty' in work && work.empty) {
+            // Server timed out the long-poll with no work. Re-poll
+            // immediately — this is the steady-state idle path.
+            continue;
+        }
+        // We have an agent.run request. Send to claude.
+        const req = work;
+        log(`👨‍🍳 new order ${req.requestId.slice(0, 10)}…  table=${req.payload.projectId || 'walk-in'}`);
+        const t0 = Date.now();
+        // Per-request AbortController — flips the moment the server-side
+        // response stream is gone (we get a 410 on POST /respond). The
+        // signal is passed into runClaudeOnce so it SIGTERMs the spawned
+        // claude child, stopping subscription token burn the moment the
+        // user clicks Stop in the workspace UI.
+        const runAbort = new AbortController();
+        try {
+            await (0, claude_runner_1.runClaudeOnce)({
+                request: req.payload,
+                requestId: req.requestId,
+                signal: runAbort.signal,
+                onEvent: (chunk) => (0, http_1.postResponse)(ctx, chunk).then(() => { }).catch((e) => {
+                    // 410 = server has no open request anymore (timeout / user
+                    // navigated away). Abort the running claude child so we
+                    // stop burning subscription tokens, then reject with
+                    // BridgeCancelled so the runtime loop logs it and moves on.
+                    if (e instanceof http_1.HttpError && e.status === 410) {
+                        try {
+                            runAbort.abort();
+                        }
+                        catch { }
+                        return Promise.reject(new BridgeCancelled());
+                    }
+                    log(`respond failed: ${e.message}`);
+                    return Promise.reject(e);
+                }),
+            });
+            log(`🍽️  served ${req.requestId.slice(0, 10)}…  ${((Date.now() - t0) / 1000).toFixed(1)}s`);
+        }
+        catch (e) {
+            if (e instanceof BridgeCancelled) {
+                log(`🗑️  order tossed ${req.requestId.slice(0, 10)}…  diner walked out`);
+                continue;
+            }
+            const msg = e.message || String(e);
+            log(`🔥 burnt ${req.requestId.slice(0, 10)}…  ${msg}`);
+            // Try to surface the error in the chat — but tolerate the case
+            // where the server already gave up.
+            await (0, http_1.postResponse)(ctx, {
+                requestId: req.requestId,
+                kind: 'error',
+                data: { message: `Bridge error: ${msg}` },
+            }).catch(() => { });
+        }
+    }
+}
+class BridgeCancelled extends Error {
+    constructor() { super('cancelled'); }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@webstew/bridge",
+  "version": "0.1.0",
+  "description": "Local bridge — run Webstew workspace AI against your Claude Code Pro/Max subscription instead of API credits.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "webstew-bridge": "./bin/webstew-bridge"
+  },
+  "files": ["dist/", "bin/", "README.md"],
+  "scripts": {
+    "build": "tsc && node -e \"const fs=require('fs'),f='dist/cli.js';let c=fs.readFileSync(f,'utf8');c=c.replace(/^#!.*\\n/,'');fs.writeFileSync(f,'#!/usr/bin/env node\\n'+c);fs.chmodSync(f,0o755)\"",
+    "prepack": "npm run build",
+    "dev": "tsx src/cli.ts"
+  },
+  "dependencies": {
+    "tsx": "^4.7.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.16",
+    "typescript": "^5.3.3"
+  },
+  "engines": { "node": ">=18" },
+  "repository": { "type": "git", "url": "https://github.com/SGK112/ai-website-builder" },
+  "keywords": ["webstew", "claude", "bridge", "ai", "website-builder"],
+  "license": "MIT"
+}