orquesta-agent 0.2.240 → 0.2.242

package/dist/index.js

@@ -102,7 +102,8 @@ async function setup() {
     console.log('  orquesta-agent ui --open');
     console.log('');
     console.log('  Then add your agents from the browser interface');
-    console.log('  URL: http://localhost:8080');
+    console.log('  URL: http://localhost:8080 (if 8080 is taken the manager picks a');
+    console.log('       free port and prints the real URL on startup)');
     console.log('');
     console.log('Or connect directly from command line:');
     console.log('  orquesta-agent --token <your-token> --daemon');
@@ -141,6 +142,104 @@ async function refreshInjectedCredentials() {
         // Non-fatal: keep the previously injected credentials.
     }
 }
+/**
+ * Commit assisted work and hand the server the raw facts: commit sha, branch,
+ * and `git diff --numstat` text.
+ *
+ * Shared by the TWO ways an assisted item gets worked — a dispatched prompt
+ * (the agent drove the CLI) and a claimed interactive session (a person sat at
+ * the terminal). Both finish identically: the server evaluates the gate and
+ * parks the item at `needs_review`. The split is the point — a gate computed on
+ * the machine being gated protects nobody, and this machine is the customer's.
+ *
+ * Best-effort throughout: a failure here must not fail work that already
+ * happened. The reviewer sees the item stuck in_progress and can nudge the run.
+ */
+async function postAssistedReport(opts) {
+    try {
+        const commit = await gitCommitAndPush(opts.execDir, opts.commitMessage);
+        // With an explicit base we always diff, even when this call committed
+        // nothing — a person working interactively may well have committed by
+        // hand, and reporting an empty diff for real work would send the reviewer
+        // an item that looks like a no-op.
+        const base = opts.diffBase && opts.diffBase !== opts.branch
+            ? opts.diffBase
+            : (commit.sha ? 'HEAD~1' : null);
+        const numstat = base ? gitNumstatSince(opts.execDir, base) : '';
+        let sha = commit.sha;
+        if (!sha && base) {
+            try {
+                sha = execSync('git rev-parse HEAD', { cwd: opts.execDir, stdio: 'pipe' }).toString().trim() || null;
+            }
+            catch { /* leave null — the server treats a missing sha as "no commit" */ }
+        }
+        const apiUrl = process.env.ORQUESTA_API_URL || 'https://getorquesta.com';
+        const res = await fetch(`${apiUrl}/api/agent/assisted-report`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                token: opts.token,
+                promptId: opts.promptId,
+                commitSha: sha,
+                branch: opts.branch,
+                numstat,
+            }),
+        });
+        if (!res.ok) {
+            logger.warn(`[assisted] report rejected (${res.status}) for item ${opts.itemId}`);
+            return;
+        }
+        logger.success(`[assisted] reported ${sha ? sha.slice(0, 8) : 'no commit'} on ${opts.branch}`);
+    }
+    catch (err) {
+        logger.warn(`[assisted] report failed: ${err}`);
+    }
+}
+/**
+ * Prepare a claimed assisted item for an interactive session: put the checkout
+ * on the run's branch and remember where it started.
+ *
+ * Returns the envelope the executor carries for the life of the session, or
+ * undefined when this session is not part of an assisted run.
+ */
+function prepareAssistedSession(assisted, sessDir) {
+    if (!assisted?.branch)
+        return undefined;
+    if (!fs.existsSync(path.join(sessDir, '.git'))) {
+        logger.warn(`[assisted] ${sessDir} is not a git checkout — session runs without branch isolation`);
+        return assisted;
+    }
+    try {
+        execSync(`git checkout ${assisted.branch} 2>/dev/null || git checkout -b ${assisted.branch}`, { cwd: sessDir, stdio: 'pipe' });
+        logger.info(`[assisted] Checked out branch: ${assisted.branch}`);
+    }
+    catch (err) {
+        logger.warn(`[assisted] Branch checkout failed: ${err}`);
+    }
+    let baseSha;
+    try {
+        baseSha = execSync('git rev-parse HEAD', { cwd: sessDir, stdio: 'pipe' }).toString().trim() || undefined;
+    }
+    catch { /* a branch with no commits yet — HEAD~1 fallback covers it */ }
+    return { ...assisted, baseSha };
+}
+/** Report a finished interactive session that was working a claimed item. */
+async function reportAssistedSession(info, token) {
+    const assisted = info.assisted;
+    if (!assisted)
+        return;
+    if (!fs.existsSync(path.join(info.workingDirectory, '.git')))
+        return;
+    await postAssistedReport({
+        token,
+        promptId: assisted.promptId,
+        itemId: assisted.itemId,
+        execDir: info.workingDirectory,
+        branch: assisted.branch,
+        diffBase: assisted.baseSha || null,
+        commitMessage: `assisted: interactive session for item ${assisted.itemId.slice(0, 8)}`,
+    });
+}
 async function connect(options) {
     logger.banner(VERSION);
     // Single-instance guard for DIRECT runs (e.g. `npx -y orquesta-agent` with no
@@ -544,7 +643,9 @@ async function connect(options) {
                     executePromptSequentialOSS(next);
                 }
             }
-            setOnSessionEnded(() => {
+            setOnSessionEnded((info) => {
+                if (info?.assisted && token)
+                    void reportAssistedSession(info, token);
                 if (promptQueue.length > 0) {
                     logger.info(`Session ended — draining ${promptQueue.length} queued prompt(s)`);
                     drainQueueOSS();
@@ -600,6 +701,8 @@ async function connect(options) {
                         else
                             logger.warn(`session:start requested dir "${rawDir}" does not exist — falling back to ${workingDirectory}`);
                     }
+                    // A claimed assisted item pins the session to the run's branch.
+                    const assisted = prepareAssistedSession(payload.assisted, sessDir);
                     // Pick up credentials created/rotated since startup before spawning.
                     void refreshInjectedCredentials().finally(() => {
                         startSession({
@@ -611,6 +714,7 @@ async function connect(options) {
                             subAgentId: payload.subAgentId,
                             subAgentName: payload.subAgentName,
                             resume: payload.resume,
+                            assisted,
                         });
                     });
                 },
@@ -691,47 +795,20 @@ async function connect(options) {
             return promptQueue.some(q => q.promptId === promptId) ||
                 [...runningExecutions.values()].some(e => e.promptId === promptId);
         }
-        /**
-         * Commit the assisted item's work and hand the server the raw facts.
-         *
-         * Facts only: the commit sha, the branch, and `git diff --numstat` text.
-         * The server evaluates the gate. That split is the point — a gate computed
-         * on the machine being gated protects nobody, and this machine belongs to
-         * the customer.
-         *
-         * Best-effort throughout: a failure here must not fail the prompt, which
-         * has already produced real work. The reviewer sees the item stuck
-         * in_progress and can nudge the run instead.
-         */
+        /** Report a finished dispatched prompt. See `postAssistedReport`. */
         async function reportAssistedResult(payload, execDir, baseBranch) {
             const assisted = payload.assisted;
-            try {
-                const commit = await gitCommitAndPush(execDir, `assisted: ${payload.content.split('\n')[0].slice(0, 120)}`);
-                // Diff against the branch we started from when we know it; otherwise
-                // the last commit only, which is what the item just produced anyway.
-                const base = baseBranch && baseBranch !== assisted.branch ? baseBranch : 'HEAD~1';
-                const numstat = commit.sha ? gitNumstatSince(execDir, base) : '';
-                const apiUrl = process.env.ORQUESTA_API_URL || 'https://getorquesta.com';
-                const res = await fetch(`${apiUrl}/api/agent/assisted-report`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        token,
-                        promptId: payload.promptId,
-                        commitSha: commit.sha,
-                        branch: assisted.branch,
-                        numstat,
-                    }),
-                });
-                if (!res.ok) {
-                    logger.warn(`[assisted] report rejected (${res.status}) for item ${assisted.itemId}`);
-                    return;
-                }
-                logger.success(`[assisted] reported ${commit.sha ? commit.sha.slice(0, 8) : 'no commit'} on ${assisted.branch}`);
-            }
-            catch (err) {
-                logger.warn(`[assisted] report failed: ${err}`);
-            }
+            if (!token)
+                return;
+            await postAssistedReport({
+                token,
+                promptId: payload.promptId,
+                itemId: assisted.itemId,
+                execDir,
+                branch: assisted.branch,
+                diffBase: baseBranch,
+                commitMessage: `assisted: ${payload.content.split('\n')[0].slice(0, 120)}`,
+            });
         }
         async function executePrompt(payload) {
             const execId = payload.id;
@@ -853,8 +930,12 @@ async function connect(options) {
                 executePrompt(next); // Fire and forget — runs concurrently
             }
         }
-        // When an interactive session ends, drain any prompts that were queued during it
-        setOnSessionEnded(() => {
+        // When an interactive session ends, report it if it was a claimed assisted
+        // item (the person's diff goes to review like any agent-produced one), then
+        // drain any prompts that were queued during it.
+        setOnSessionEnded((info) => {
+            if (info?.assisted && token)
+                void reportAssistedSession(info, token);
             if (promptQueue.length > 0) {
                 logger.info(`Session ended — draining ${promptQueue.length} queued prompt(s)`);
                 drainQueue();
@@ -1060,6 +1141,11 @@ async function connect(options) {
                     logger.warn(`[workstream:${subCfg.name}] Branch checkout failed: ${err}`);
                 }
             }
+            // A claimed assisted item pins the session to the run's branch. It runs
+            // AFTER the workstream checkout above so an assisted claim wins — the
+            // two are never combined in the UI, and the run's isolation is the
+            // whole reason the branch exists.
+            const assisted = prepareAssistedSession(payload.assisted, sessDir);
             // Pick up credentials created/rotated since startup before spawning.
             void refreshInjectedCredentials().finally(() => {
                 startSession({
@@ -1072,6 +1158,7 @@ async function connect(options) {
                     subAgentName: payload.subAgentName || subCfg?.name,
                     resume: payload.resume,
                     resumeSessionId: payload.resumeSessionId,
+                    assisted,
                 });
             });
         }, 
@@ -1215,7 +1302,7 @@ async function connect(options) {
             logger.info('Agent is ready and waiting for prompts...');
             if (channel && validation.channelName) {
                 setLocalServerContext(channel, validation.channelName);
-                startLocalServer().catch(err => logger.warn(`local server failed to start: ${err?.message || err}`));
+                startLocalServer(options.localPort).catch(err => logger.warn(`local server failed to start: ${err?.message || err}`));
             }
             // First-run only: open the guided welcome tour (or print its URL on a
             // headless host). Wired to the live agent so the "Configure now" step
@@ -1545,6 +1632,7 @@ program
     .option('--cli-preference <preference>', 'CLI preference: auto (prefer orquesta), orquesta, claude, kimi, or cursor (cursor-agent). Defaults to auto.')
     .option('--mode <mode>', 'Alias for --cli-preference: auto, orquesta, claude, kimi or cursor')
     .option('--renew', 'Rotate this agent token: mint a fresh oat_, revoke the current one, print the new token, and exit. Update your start command/script with it to reconnect.')
+    .option('--port <port>', 'Port for the agent\'s local bridge (default 7790). NOT the manager UI port — that one is `orquesta-agent ui --port <port>`.')
     .option('-D, --daemon', 'Run in daemon mode with automatic restart on exit')
     .option('--max-restarts <number>', 'Maximum restart attempts in daemon mode (0=unlimited)', '0')
     .action((options) => {
@@ -1571,6 +1659,20 @@ program
         logger.error('Invalid CLI preference/mode. Use "auto", "orquesta", "claude", or "kimi".');
         process.exit(1);
     }
+    // `--port` used to be an UNKNOWN option on this command, and commander
+    // exits(1) on those: the second agent someone started with
+    // `orquesta-agent --token … --port 8081` (after the manager reported 8080
+    // busy) never ran at all, so its project sat grey in the dashboard forever
+    // and the port looked like the culprit. QA-54.
+    let localPort;
+    if (options.port !== undefined) {
+        localPort = parseInt(String(options.port), 10);
+        if (!Number.isFinite(localPort) || localPort < 0 || localPort > 65535) {
+            logger.error(`Invalid --port "${options.port}". Use a number between 0 and 65535.`);
+            process.exit(1);
+        }
+        logger.info(`Local bridge port set to ${localPort}. (The web manager's port is separate: orquesta-agent ui --port <port>.)`);
+    }
     // Check if daemon mode is requested (and we're not already a daemon child)
     if (options.daemon && !isDaemonChild()) {
         // Start in daemon mode - this will spawn the agent as a child process
@@ -1595,6 +1697,7 @@ program
         sandboxMode: options.sandboxStrict === true ? 'strict' : undefined,
         cliPreference: options.cliPreference,
         agentName: options.name,
+        localPort,
     });
 });
 // Hook command — Claude Code / Cursor hook event handler