@tea-agent/loop-agent 0.43.0-next.2 → 0.43.0-next.4

package/dist/worker/console/chat/explore-tools.js

@@ -71,6 +71,10 @@ export const SECRET_SCRUB_PATTERNS = [
         name: "private-key-block",
         re: /-----BEGIN (?:RSA |EC |OPENSSH |DSA |)PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA |)PRIVATE KEY-----/g,
     },
+    {
+        name: "aimax-auth-token",
+        re: /\bAIMAX_AUTH_TOKEN=["']?[^\s"']+/g,
+    },
 ];
 /** Throw a typed explore error (kept as a value object so callers can read .code). */
 export class ExploreDeniedError extends Error {
@@ -89,6 +93,10 @@ export class ExploreDeniedError extends Error {
  */
 export function scrubSecrets(input) {
     let out = input;
+    const liveToken = process.env.AIMAX_AUTH_TOKEN;
+    if (liveToken && liveToken.length >= 8 && out.includes(liveToken)) {
+        out = out.split(liveToken).join("[REDACTED:aimax-auth-token]");
+    }
     const redactions = [];
     for (const { name, re } of SECRET_SCRUB_PATTERNS) {
         re.lastIndex = 0;
@@ -98,6 +106,11 @@ export function scrubSecrets(input) {
             redactions.push({ name, count: matches.length });
         }
     }
+    if (liveToken && liveToken.length >= 8 && input.includes(liveToken)) {
+        const existing = redactions.find((entry) => entry.name === "aimax-auth-token");
+        if (!existing)
+            redactions.push({ name: "aimax-auth-token", count: 1 });
+    }
     return { scrubbed: out, redactions };
 }
 /** True if a repo-relative path matches a sensitive-file denylist pattern. */

package/dist/worker/console/chat/pi-runtime.js

@@ -43,6 +43,7 @@ import { resolveDefaultChatModel, resolveLowChatModel, } from "./model-resolver.
 import { filterActiveInterviewTools } from "../interview/tools.js";
 import { RUNTIME_CONTEXT_TEXT_MAX, redactRuntimeText, } from "./runtime-context.js";
 import { buildTodoContinuationContext, } from "./todos.js";
+import { buildPersistentTerminalTools } from "./terminal-tools.js";
 import { buildGoalContinuationContext, } from "./goals.js";
 import { injectWizardLocalHeaders, } from "./sdd-data-alignment.js";
 /**
@@ -1054,6 +1055,9 @@ export class ConsolePiRuntime {
             },
         });
     }
+    async syncAimaxAuthToken() {
+        await this.options.sddDataAlignment?.auth?.getToken();
+    }
     /** Absolute path for repo-scoped resource preferences (may be undefined in unit tests). */
     get resourcePreferencesPath() {
         return this.options.resourcePreferencesPath;
@@ -1341,6 +1345,7 @@ export class ConsolePiRuntime {
      * `initializing: true`; dependent routes wait on the same promise.
      */
     async createSession(init) {
+        await this.syncAimaxAuthToken();
         const sessionId = `operator-chat-${randomBytes(12).toString("hex")}`;
         this.disposedSessions.delete(sessionId);
         const sessionManager = await this.bindings.createSessionManager({
@@ -1438,6 +1443,7 @@ export class ConsolePiRuntime {
     async materializeSession(sessionId, init) {
         if (this.disposedSessions.has(sessionId))
             return;
+        await this.syncAimaxAuthToken();
         const agentDir = await safeGetAgentDir(this.bindings);
         // Capture before services parse models.json. A concurrent edit can therefore
         // cause at most one harmless extra refresh, never a missed next-turn refresh.
@@ -1547,6 +1553,16 @@ export class ConsolePiRuntime {
         const goalTools = this.options.goalRegistry
             ? await buildGoalTools({ sessionId, registry: this.options.goalRegistry })
             : [];
+        const terminalTools = this.options.terminalRegistry
+            ? await buildPersistentTerminalTools({
+                ownerSessionId: sessionId,
+                registry: this.options.terminalRegistry,
+                defaultCwd: this.options.cwd,
+            }).catch((error) => {
+                process.stderr.write(`[console] chat terminal-tools build failed: ${error instanceof Error ? error.message : String(error)}\n`);
+                return [];
+            })
+            : [];
         const agentTool = await buildAgentCustomTool({
             parentSessionId: sessionId,
             orchestrator: this.exploreOrchestrator,
@@ -1571,6 +1587,7 @@ export class ConsolePiRuntime {
             ...(questionTool ? [questionTool] : []),
             ...(todoTool ? [todoTool] : []),
             ...goalTools,
+            ...terminalTools,
             ...(agentTool ? [agentTool] : []),
         ];
     }
@@ -2347,6 +2364,7 @@ export class ConsolePiRuntime {
      * than silently creating a fresh empty session and losing prior context.
      */
     async reopenSession(init) {
+        await this.syncAimaxAuthToken();
         const sessionId = init.sessionId;
         // Wait for in-flight create materialization rather than racing reopen.
         const initState = this.sessionInit.get(sessionId);

package/dist/worker/console/chat/routes.js

@@ -44,6 +44,8 @@ import { buildGoalCompactionInstructions, buildGoalContinuationContext, } from "
 import { classifyGoalRoundAdmission, } from "./goal-round-driver.js";
 import { isTerminalOperationState } from "../../../infrastructure/console/operation-store.js";
 import { SddDataAlignmentError, } from "./sdd-data-alignment.js";
+import { TerminalSessionRegistry } from "./terminal-sessions.js";
+import { handleTerminalRequest } from "./terminal-routes.js";
 function projectBrowserChatSession(record) {
     const { telemetrySessionId, ...projected } = record;
     void telemetrySessionId;
@@ -4146,6 +4148,15 @@ export async function handleChatMessages(res, deps, sessionId, url) {
 export async function handleChatRequest(req, res, deps, pathname, workspaceScope) {
     if (!deps)
         return false;
+    // Terminal management API (model + Console UI shared PTY registry).
+    if (await handleTerminalRequest(req, res, {
+        terminals: deps.terminals ?? new TerminalSessionRegistry(),
+        gateMutation: (r) => gateMutation(r, deps),
+        // Terminals open in the workspace repo root, not the Console process cwd.
+        defaultCwd: deps.appData.repoRoot,
+    }, pathname)) {
+        return true;
+    }
     if (!pathname.startsWith("/api/operator/v1/chat/") &&
         !pathname.startsWith("/api/operator/v1/pi/"))
         return false;

package/dist/worker/console/chat/sdd-data-alignment.js

@@ -1,4 +1,4 @@
-import { randomBytes } from "node:crypto";
+import { createDecipheriv, randomBytes } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
@@ -10,8 +10,49 @@ export const SDD_SKILL_NAMES = [
 /** Backward-compatible name for callers that need a stable representative value. */
 export const SDD_DEFAULT_SKILL_NAME = "SDD-implementation-test-review";
 export const SDD_TELEMETRY_URL = "https://wizard-ai.paic.com.cn/code_pilot/api/skill-usage-log";
-export const SDD_TELEMETRY_SIGN = "52aad0c09e6b46818a11ee702d6fe0ba";
+/** SM4 key hex; also the SDD telemetry `ws-sign` value. */
+export const DEFAULT_AI_MA_PUB_SALT_KEY = "52aad0c09e6b46818a11ee702d6fe0ba";
+export const SDD_TELEMETRY_SIGN = DEFAULT_AI_MA_PUB_SALT_KEY;
+export const AIMAX_AUTH_TOKEN_ENV = "AIMAX_AUTH_TOKEN";
 export const WIZARD_LOCAL_DEFAULT_USER_AGENT = "Builder/OpenCode ai-sdk/provider-utils/4.0.21 runtime/bun/1.3.11";
+const SM4_V1_PREFIX = "sm4:v1:";
+/** Decode a plaintext ticket or `sm4:v1:` ciphertext. Unknown prefixes and crypto errors fail closed. */
+export function decodeAimaxAuthToken(raw, keyHex = DEFAULT_AI_MA_PUB_SALT_KEY) {
+    const candidate = raw.trim();
+    if (!candidate)
+        return undefined;
+    if (!candidate.startsWith("sm4:"))
+        return candidate;
+    if (!candidate.startsWith(SM4_V1_PREFIX))
+        return undefined;
+    const hex = candidate.slice(SM4_V1_PREFIX.length);
+    if (!hex || hex.length % 2 !== 0 || /[^0-9a-fA-F]/.test(hex))
+        return undefined;
+    const key = Buffer.from(keyHex.trim(), "hex");
+    if (key.length !== 16)
+        return undefined;
+    try {
+        const encrypted = Buffer.from(hex, "hex");
+        if (encrypted.length === 0 || encrypted.length % 16 !== 0)
+            return undefined;
+        const decipher = createDecipheriv("sm4-ecb", key, null);
+        decipher.setAutoPadding(true);
+        const plain = Buffer.concat([decipher.update(encrypted), decipher.final()])
+            .toString("utf8")
+            .trim();
+        return plain || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Set or delete `AIMAX_AUTH_TOKEN`. Empty string is treated as absent. */
+export function syncAimaxAuthTokenEnv(env, token) {
+    if (token)
+        env[AIMAX_AUTH_TOKEN_ENV] = token;
+    else
+        delete env[AIMAX_AUTH_TOKEN_ENV];
+}
 function sameAuthFileVersion(left, right) {
     if (!left.exists || !right.exists)
         return left.exists === right.exists;
@@ -21,9 +62,22 @@ function sameAuthFileVersion(left, right) {
 /** Reads ~/.aima-go/auth.json with metadata-based parse caching and fail-closed semantics. */
 export class AimaxAuthReader {
     authFile;
+    env;
     cached;
-    constructor(authFile = path.join(os.homedir(), ".aima-go", "auth.json")) {
+    constructor(authFile = path.join(os.homedir(), ".aima-go", "auth.json"), env = process.env) {
         this.authFile = authFile;
+        this.env = env;
+    }
+    resolveKeyHex() {
+        const injected = typeof this.env.AI_MA_PUB_SALT_KEY === "string" ? this.env.AI_MA_PUB_SALT_KEY.trim() : "";
+        if (injected)
+            return injected;
+        const host = process.env.AI_MA_PUB_SALT_KEY?.trim();
+        return host || DEFAULT_AI_MA_PUB_SALT_KEY;
+    }
+    finish(token) {
+        syncAimaxAuthTokenEnv(this.env, token);
+        return token;
     }
     async getToken() {
         let version;
@@ -34,22 +88,24 @@ export class AimaxAuthReader {
         }
         catch {
             this.cached = { version: { exists: false } };
-            return undefined;
+            return this.finish(undefined);
+        }
+        if (this.cached && sameAuthFileVersion(this.cached.version, version)) {
+            return this.finish(this.cached.token);
         }
-        if (this.cached && sameAuthFileVersion(this.cached.version, version))
-            return this.cached.token;
         let token;
         try {
             const parsed = JSON.parse(await readFile(this.authFile, "utf8"));
             const candidate = parsed["aimax-auth-token"];
-            if (typeof candidate === "string" && candidate.trim())
-                token = candidate;
+            if (typeof candidate === "string" && candidate.trim()) {
+                token = decodeAimaxAuthToken(candidate, this.resolveKeyHex());
+            }
         }
         catch {
             // Malformed or unreadable files are intentionally ineligible.
         }
         this.cached = { version, ...(token ? { token } : {}) };
-        return token;
+        return this.finish(token);
     }
     async isEligible() {
         return Boolean(await this.getToken());

package/dist/worker/console/chat/terminal-routes.js

@@ -0,0 +1,216 @@
+/**
+ * Operator Chat — terminal management HTTP API (Console UI side).
+ *
+ * Endpoints (all under /api/operator/v1/chat):
+ *   GET  /terminals                          list terminal sessions (all owners)
+ *   POST /terminals                          spawn { shell, name?, cwd?, ownerSessionId? }
+ *   GET  /terminals/:id                      session info + buffered output
+ *   POST /terminals/:id/input                { data }  write to the PTY
+ *   POST /terminals/:id/resize               { cols, rows }
+ *   POST /terminals/:id/interrupt            send Ctrl+C
+ *   POST /terminals/:id/kill                 stop and await full exit
+ *   GET  /terminals/:id/stream               SSE: buffered replay + live chunks
+ *
+ * Mutating routes require the Console boot token (same gate as other chat
+ * mutations). The stream is read-only and uses the same origin checks as the
+ * chat event stream.
+ */
+import { TerminalSessionError, availableShellKinds, } from "./terminal-sessions.js";
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+    });
+    res.end(payload);
+}
+function mapTerminalError(res, error) {
+    if (error instanceof TerminalSessionError) {
+        const status = error.code === "TERMINAL_NOT_FOUND"
+            ? 404
+            : error.code === "TERMINAL_EXITED" || error.code === "TERMINAL_SEND_ACTIVE"
+                ? 409
+                : 500;
+        sendJson(res, status, {
+            ok: false,
+            error: { code: error.code, message: error.message },
+        });
+        return;
+    }
+    sendJson(res, 500, {
+        ok: false,
+        error: {
+            code: "TERMINAL_INTERNAL",
+            message: error instanceof Error ? error.message : String(error),
+        },
+    });
+}
+async function readJsonBody(req, maxBytes = 512 * 1024) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        total += buf.length;
+        if (total > maxBytes)
+            throw new Error("request body too large");
+        chunks.push(buf);
+    }
+    if (chunks.length === 0)
+        return {};
+    const raw = Buffer.concat(chunks).toString("utf8");
+    if (!raw.trim())
+        return {};
+    return JSON.parse(raw);
+}
+/** Route dispatcher; returns true when the request was handled. */
+export async function handleTerminalRequest(req, res, deps, pathname) {
+    if (!pathname.startsWith("/api/operator/v1/chat/terminals"))
+        return false;
+    const method = (req.method ?? "GET").toUpperCase();
+    const rest = pathname.slice("/api/operator/v1/chat/terminals".length);
+    const parts = rest.split("/").filter(Boolean);
+    try {
+        // GET /terminals — list (+ available shell kinds for this platform)
+        if (method === "GET" && parts.length === 0) {
+            sendJson(res, 200, {
+                ok: true,
+                data: {
+                    terminals: deps.terminals.list(),
+                    availableShells: availableShellKinds().kinds,
+                },
+            });
+            return true;
+        }
+        // POST /terminals — spawn
+        if (method === "POST" && parts.length === 0) {
+            const gate = deps.gateMutation(req);
+            if (!gate.ok) {
+                sendJson(res, gate.status, { ok: false, error: { code: gate.code, message: gate.message } });
+                return true;
+            }
+            const body = await readJsonBody(req);
+            const kinds = availableShellKinds().kinds;
+            const shell = kinds.includes(body.shell)
+                ? body.shell
+                : undefined;
+            if (!shell) {
+                sendJson(res, 400, {
+                    ok: false,
+                    error: {
+                        code: "INVALID_INPUT",
+                        message: `shell must be one of: ${kinds.join(", ")} (available on this platform)`,
+                    },
+                });
+                return true;
+            }
+            const info = deps.terminals.spawn({
+                ownerSessionId: typeof body.ownerSessionId === "string" && body.ownerSessionId
+                    ? body.ownerSessionId
+                    : "console-ui",
+                name: typeof body.name === "string" && body.name ? body.name : `${shell}-ui`,
+                shell: shell,
+                cwd: typeof body.cwd === "string" && body.cwd
+                    ? body.cwd
+                    : (deps.defaultCwd ?? undefined),
+                cols: typeof body.cols === "number" ? body.cols : undefined,
+                rows: typeof body.rows === "number" ? body.rows : undefined,
+            });
+            sendJson(res, 201, { ok: true, data: info });
+            return true;
+        }
+        const sessionId = parts[0];
+        if (!sessionId)
+            return false;
+        const sub = parts[1] ?? "";
+        // GET /terminals/:id — info + buffered output
+        if (method === "GET" && parts.length === 1) {
+            const info = deps.terminals.get(sessionId);
+            const output = deps.terminals.readAll(sessionId);
+            sendJson(res, 200, { ok: true, data: { ...info, output } });
+            return true;
+        }
+        // GET /terminals/:id/stream — SSE
+        if (method === "GET" && sub === "stream") {
+            // Validate existence first (404 before opening the stream).
+            const info = deps.terminals.get(sessionId);
+            void info;
+            res.writeHead(200, {
+                "content-type": "text/event-stream; charset=utf-8",
+                "cache-control": "no-cache, no-store",
+                connection: "keep-alive",
+                "x-accel-buffering": "no",
+            });
+            const writeFrame = (event, data) => {
+                if (res.writableEnded)
+                    return;
+                res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+            };
+            const buffered = deps.terminals.readAll(sessionId);
+            writeFrame("snapshot", {
+                truncated: buffered.truncated,
+                totalOutputChars: buffered.totalOutputChars,
+                text: buffered.text,
+                info: deps.terminals.get(sessionId),
+            });
+            const unsubscribe = deps.terminals.subscribe(sessionId, (chunk) => {
+                writeFrame("data", { chunk });
+            });
+            const heartbeat = setInterval(() => {
+                if (!res.writableEnded)
+                    res.write(": heartbeat\n\n");
+            }, 15_000);
+            res.once("close", () => {
+                clearInterval(heartbeat);
+                unsubscribe();
+            });
+            return true;
+        }
+        // Everything else mutates → gate first.
+        const gate = deps.gateMutation(req);
+        if (!gate.ok) {
+            sendJson(res, gate.status, { ok: false, error: { code: gate.code, message: gate.message } });
+            return true;
+        }
+        if (method === "POST" && sub === "input" && parts.length === 2) {
+            const body = await readJsonBody(req);
+            if (typeof body.data !== "string") {
+                sendJson(res, 400, { ok: false, error: { code: "INVALID_INPUT", message: "data (string) is required" } });
+                return true;
+            }
+            deps.terminals.send(sessionId, body.data);
+            sendJson(res, 200, { ok: true });
+            return true;
+        }
+        if (method === "POST" && sub === "resize" && parts.length === 2) {
+            const body = await readJsonBody(req);
+            const cols = Number(body.cols);
+            const rows = Number(body.rows);
+            if (!Number.isInteger(cols) || !Number.isInteger(rows) || cols < 2 || rows < 2 || cols > 500 || rows > 200) {
+                sendJson(res, 400, { ok: false, error: { code: "INVALID_INPUT", message: "cols and rows (integers 2..500/200) are required" } });
+                return true;
+            }
+            deps.terminals.resize(sessionId, cols, rows);
+            sendJson(res, 200, { ok: true });
+            return true;
+        }
+        if (method === "POST" && sub === "interrupt" && parts.length === 2) {
+            deps.terminals.interrupt(sessionId);
+            sendJson(res, 200, { ok: true });
+            return true;
+        }
+        if (method === "POST" && sub === "kill" && parts.length === 2) {
+            await deps.terminals.kill(sessionId);
+            sendJson(res, 200, { ok: true });
+            return true;
+        }
+        sendJson(res, 404, { ok: false, error: { code: "NOT_FOUND", message: `unknown terminal route: ${method} ${pathname}` } });
+        return true;
+    }
+    catch (error) {
+        if (!res.headersSent)
+            mapTerminalError(res, error);
+        else
+            res.end();
+        return true;
+    }
+}