castle-web-cli 0.4.57 → 0.4.59

package/dist/agent-prompts.d.ts

@@ -1,6 +1,7 @@
 export interface PromptMessage {
     role: "user" | "assistant";
     text: string;
+    interrupted?: boolean;
 }
 export interface PromptTask {
     id: string;
@@ -16,7 +17,7 @@ export declare function buildRouterPrompt(opts: {
     instruction: string;
 }): string;
 export declare function userTurnInstruction(opts: {
-    text: string;
+    messages: string[];
     interruptedDraft?: string;
     attachments?: string[];
 }): string;

package/dist/agent-prompts.js

@@ -61,7 +61,14 @@ function renderTranscript(messages) {
     if (recent.length === 0)
         return "(no conversation yet)";
     return recent
-        .map((m) => `${m.role === "user" ? "user" : "you"}: ${m.text}`)
+        .map((m) => {
+        if (m.role === "user")
+            return `user: ${m.text}`;
+        const label = m.interrupted
+            ? "you (interrupted draft -- not a complete reply)"
+            : "you";
+        return `${label}: ${m.text}`;
+    })
         .join("\n\n");
 }
 function renderTasks(tasks) {
@@ -94,9 +101,17 @@ Reply now, as "you" in the conversation. Plain reply text only -- no role prefix
 export function userTurnInstruction(opts) {
     const parts = [];
     if (opts.interruptedDraft?.trim()) {
-        parts.push(`Your previous reply was interrupted mid-stream by the user's new message. Its draft so far (already shown to the user; NO tasks were spawned from it):\n\n${opts.interruptedDraft.trim()}\n\nContinue that line of work AND address the new message -- do both in this one reply, spawning whatever tasks are needed for either.`);
+        parts.push(`Your previous reply was interrupted mid-stream by the user's new message. Its draft so far (already shown to the user; NO tasks were spawned from it):\n\n${opts.interruptedDraft.trim()}\n\nContinue that line of work AND address the new message(s) -- do it all in this one reply, spawning whatever tasks are needed.`);
+    }
+    const msgs = opts.messages.filter((m) => m.trim());
+    if (msgs.length <= 1) {
+        parts.push(`The user just said:\n\n${msgs[0] ?? ""}`);
+    }
+    else {
+        parts.push(`The user sent these messages -- the earlier ones arrived while you were mid-reply and have NOT been answered yet. Address ALL of them in this one reply, in order. Exception: if a later message clearly clarifies, corrects, or takes back an earlier one, follow the later intent and don't redo work the user reversed. By default, cover every message:\n\n${msgs
+            .map((t, i) => `${i + 1}. ${t}`)
+            .join("\n\n")}`);
     }
-    parts.push(`The user just said:\n\n${opts.text}`);
     if (opts.attachments && opts.attachments.length > 0) {
         parts.push(`The user attached image file(s), saved in the deck at: ${opts.attachments.join(", ")}. Open them with your read tool and take them into account; pass the paths along to task agents that need them.`);
     }

package/dist/agent.js

@@ -16,6 +16,7 @@
 // --force. Claude support can slot in later behind runAgentCli.
 import { execFileSync, spawn } from 'child_process';
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { nanoid } from 'nanoid';
 import { WebSocketServer } from 'ws';
@@ -187,6 +188,56 @@ function toolActivityLabel(ev) {
         return 'running a command';
     return 'working';
 }
+// Castle's agent CLI keys, delivered to the sandbox as a file
+// (~/.castle/keys.json) rather than sandbox-wide env -- so an ambient key can't
+// override a user's own subscription login. Falls back to process.env for
+// older sandboxes that still inject the keys as env.
+const CASTLE_KEYS_PATH = path.join(os.homedir(), '.castle', 'keys.json');
+function castleKeys() {
+    try {
+        return JSON.parse(fs.readFileSync(CASTLE_KEYS_PATH, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+const BACKEND_KEY_ENV = {
+    claude: 'ANTHROPIC_API_KEY',
+    cursor: 'CURSOR_API_KEY',
+};
+// True when the user has their OWN saved auth for this backend -- a /login, or
+// (for cursor, which reuses one auth.json) any saved creds. When so we do NOT
+// inject Castle's key, so their auth is used and billed to them.
+function backendHasSavedAuth(backend) {
+    const home = os.homedir();
+    if (backend === 'claude') {
+        return fs.existsSync(path.join(home, '.claude', '.credentials.json'));
+    }
+    if (backend === 'cursor') {
+        return fs.existsSync(path.join(home, '.config', 'cursor', 'auth.json'));
+    }
+    return false;
+}
+// Env for an agent spawn: inject Castle's key ONLY when the backend has no saved
+// auth of the user's own. This is what lets internal testers run on their own
+// subscription (log in once in the terminal) instead of Castle's key.
+function envForAgentSpawn(backend) {
+    const env = { ...process.env };
+    const keyName = BACKEND_KEY_ENV[backend];
+    if (!keyName)
+        return env;
+    if (backendHasSavedAuth(backend)) {
+        delete env[keyName];
+    }
+    else {
+        const val = castleKeys()[keyName] ?? process.env[keyName];
+        if (val)
+            env[keyName] = val;
+        else
+            delete env[keyName];
+    }
+    return env;
+}
 // One headless agent CLI run (cursor or claude), normalized to the same
 // delta/activity/result hooks. Cursor: assistant events carrying timestamp_ms
 // are text deltas; the trailing assistant event without one repeats the whole
@@ -196,7 +247,7 @@ function runAgentCli(opts) {
     return new Promise((resolve) => {
         const child = spawn(opts.command, opts.args, {
             cwd: opts.cwd,
-            env: process.env,
+            env: envForAgentSpawn(opts.parser),
             stdio: ['ignore', 'pipe', 'pipe'],
         });
         opts.children.add(child);
@@ -793,7 +844,11 @@ function runRouterTurnIn(ctx, instruction) {
         deckLabel: ctx.deckLabel,
         messages: ctx.log.messages
             .filter((m) => m.role !== 'log' && m.id !== message.id && m.status !== 'streaming')
-            .map((m) => ({ role: m.role, text: m.text })),
+            .map((m) => ({
+            role: m.role,
+            text: m.text,
+            interrupted: m.interrupted,
+        })),
         // Only the live board -- match what the user sees. Hide tasks that are
         // BOTH acknowledged AND finished; an active (running/waiting) task always
         // shows even if somehow acked, so nothing can ever go invisible mid-work.
@@ -1036,6 +1091,20 @@ export function createAgentServer(opts) {
             claudeModel: () => settings.claudeModel,
         }, instruction);
     }
+    // User messages awaiting a reply: everything since the last COMPLETED (done,
+    // not interrupted) assistant message. Usually just the latest, but a rapid
+    // burst leaves several queued -- all must be addressed, not only the last.
+    function pendingUserMessages() {
+        let lastAnswered = -1;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const m = messages[i];
+            if (m.role === 'assistant' && m.status === 'done' && !m.interrupted) {
+                lastAnswered = i;
+                break;
+            }
+        }
+        return messages.slice(lastAnswered + 1).filter((m) => m.role === 'user');
+    }
     function handleUserMessage(text, images) {
         userEpoch += 1;
         const interruptedDraft = interruptRouterRuns();
@@ -1051,10 +1120,15 @@ export function createAgentServer(opts) {
         if (attachments.length > 0)
             message.attachments = attachments;
         log.add(message);
+        // Address every still-unanswered user message (this one plus any earlier
+        // burst messages that interrupted prior turns), not just the latest.
+        const pending = pendingUserMessages();
         runRouterTurn(userTurnInstruction({
-            text,
+            messages: pending.map((m) => m.text),
             interruptedDraft: interruptedDraft || undefined,
-            attachments: attachments.map((name) => path.join('.castle', 'agent', 'attachments', name)),
+            attachments: pending
+                .flatMap((m) => m.attachments ?? [])
+                .map((name) => path.join('.castle', 'agent', 'attachments', name)),
         }));
     }
     function handleTaskAck(id, rejected) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "castle-web-cli",
-  "version": "0.4.57",
+  "version": "0.4.59",
   "type": "module",
   "bin": {
     "castle-web": "./dist/index.js"