nolo-cli 0.1.11 → 0.1.12

package/agentRuntimeCommands.ts

@@ -1,10 +1,10 @@
-import type { MachineHeartbeat } from "connector-experimental/protocol";
-import { detectMachineInfo } from "connector-experimental/machineInfo";
+import type { MachineHeartbeat } from "./connector-experimental/protocol";
+import { detectMachineInfo } from "./connector-experimental/machineInfo";
 import {
   assertMachineRunAllowed,
   buildMachinePermissionPromptBlock,
   resolveMachineRunPermissionPolicy,
-} from "../ai/agent/machineRunPermissions";
+} from "./ai/agent/machineRunPermissions";
 import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
 import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 
@@ -56,7 +56,7 @@ function readOption(args: string[], flag: string) {
 }
 
 async function defaultExecuteCli(provider: string, prompt: string, options: { model?: string; yolo?: boolean }) {
-  const { executeCli } = await import("ai/agent/cliExecutor");
+  const { executeCli } = await import("./ai/agent/cliExecutor");
   return executeCli(provider as any, prompt, options);
 }
 

package/ai/agent/cliExecutor.ts

@@ -0,0 +1,733 @@
+/**
+ * CLI Executor - 通过命令行工具执行 AI 任务
+ *
+ * 设计为可扩展：当前支持 Copilot CLI、Gemini CLI、Codex CLI 与 Claude CLI。
+ *
+ * 注意：
+ * - CLI provider 与普通 model 路由共享 prompt / model / 最近文本上下文这些能力面
+ * - 但 CLI 不暴露本仓库可编排的 tool-calls 协议，因此这里只返回文本结果
+ * - 对缺少稳定增量输出协议的 CLI，流式接口允许退化为“完成后一次性回传”
+ *
+ * 使用方式：
+ *   import { executeCli } from "ai/agent/cliExecutor";
+  *   const result = await executeCli("copilot", prompt, { model: "claude-haiku-4.5" });
+ */
+
+import { exec, spawn } from "child_process";
+import { randomUUID } from "node:crypto";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { buildCliPrompt } from "./cliPrompt";
+
+// ── 类型定义 ──────────────────────────────────────────────────────────────────
+
+/** 已支持的 CLI 工具。新增时在此联合类型追加，并在 EXECUTORS 里注册实现 */
+export type CliProvider = "copilot" | "gemini" | "codex" | "claude";
+
+export interface CliExecuteOptions {
+  model?: string;
+  timeout?: number;   // ms，默认 120_000
+  cwd?: string;
+  yolo?: boolean;     // 允许所有工具，默认 true（后台任务常用）
+}
+
+export interface CliExecuteResult {
+  text: string;       // 解析后的纯文本回复
+  raw: string;        // 原始 stdout
+  elapsed: number;    // 耗时 ms
+}
+
+type CliSessionMessage = {
+  role: "user" | "assistant";
+  content: string;
+};
+
+export interface CliSessionHandle {
+  sessionId: string;
+  provider: CliProvider;
+}
+
+export interface CliSessionState extends CliSessionHandle {
+  systemPrompt?: string;
+  options: CliExecuteOptions;
+  messages: CliSessionMessage[];
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface CliSessionTurnResult extends CliExecuteResult {
+  sessionId: string;
+}
+
+const cliSessions = new Map<string, CliSessionState>();
+
+// ── 各 provider 实现 ─────────────────────────────────────────────────────────
+
+/**
+ * Copilot CLI 执行器
+ * 调用 gh copilot -- -p "..." --silent
+ */
+function executeCopilot(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const {
+    model,
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      "NO_COLOR=1",
+      "gh copilot --",
+      `-p ${JSON.stringify(prompt)}`,
+      "--silent",
+      "--disable-builtin-mcps",
+      "--stream off",
+      "--no-color",
+    ];
+    if (model) args.push(`--model ${model}`);
+    if (yolo) args.push("--yolo");
+
+    const cmd = args.join(" ");
+    const start = Date.now();
+
+    exec(
+      cmd,
+      { timeout, cwd, env: { ...process.env } },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.killed && (error as any).signal === "SIGTERM") {
+            return reject(new Error(`Copilot CLI timed out after ${timeout}ms`));
+          }
+          return reject(
+            new Error(`Copilot CLI failed: ${error.message}\nstderr: ${stderr}`)
+          );
+        }
+
+        const text = stdout
+          .split("\n")
+          .filter((l) => !l.includes("A new release of gh is available"))
+          .filter((l) => !l.includes("To upgrade, run:"))
+          .filter((l) => !l.includes("https://github.com/cli/cli/releases"))
+          .join("\n")
+          .trim();
+
+        resolve({ text, raw: stdout, elapsed: Date.now() - start });
+      }
+    );
+  });
+}
+
+function normalizeGeminiContent(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part === "object" && typeof (part as any).text === "string") {
+          return (part as any).text;
+        }
+        return "";
+      })
+      .join("");
+  }
+  if (content && typeof content === "object" && typeof (content as any).text === "string") {
+    return (content as any).text;
+  }
+  return "";
+}
+
+function extractGeminiEventText(event: any): string {
+  if (event?.type === "message" && event.role === "assistant") {
+    return normalizeGeminiContent(event.content);
+  }
+  if (event?.type === "result" && typeof event.result === "string") {
+    return event.result;
+  }
+  return "";
+}
+
+function parseGeminiStreamJson(stdout: string): string {
+  const parts: string[] = [];
+
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    try {
+      const event = JSON.parse(trimmed);
+      const text = extractGeminiEventText(event);
+      if (text) parts.push(text);
+    } catch {
+      // ignore malformed lines
+    }
+  }
+
+  return parts.join("");
+}
+
+function executeGemini(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const {
+    model = "gemini-3-flash-preview",
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      "NO_COLOR=1",
+      "NODE_OPTIONS='--no-deprecation'",
+      "gemini",
+      `-p ${JSON.stringify(prompt)}`,
+      "--output-format stream-json",
+      `-m ${JSON.stringify(model)}`,
+    ];
+    if (yolo) args.push("--yolo");
+    args.push("-e none");
+
+    const cmd = args.join(" ");
+    const start = Date.now();
+
+    exec(
+      cmd,
+      { timeout, cwd, env: { ...process.env } },
+      (error, stdout, stderr) => {
+        if (error) {
+          if (error.killed && (error as any).signal === "SIGTERM") {
+            return reject(new Error(`Gemini CLI timed out after ${timeout}ms`));
+          }
+          return reject(
+            new Error(`Gemini CLI failed: ${error.message}\nstderr: ${stderr}`)
+          );
+        }
+
+        resolve({
+          text: parseGeminiStreamJson(stdout),
+          raw: stdout,
+          elapsed: Date.now() - start,
+        });
+      }
+    );
+  });
+}
+
+function executeCodex(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const {
+    model,
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const tempDir = mkdtempSync(join(tmpdir(), "codex-exec-"));
+    const outputFile = join(tempDir, "last-message.txt");
+    const args = [
+      "exec",
+      "--skip-git-repo-check",
+      "--ephemeral",
+      "--color",
+      "never",
+      "--output-last-message",
+      outputFile,
+      "--cd",
+      cwd,
+    ];
+    if (model) {
+      args.push("--model");
+      args.push(model);
+    }
+    if (yolo) {
+      args.push("--sandbox");
+      args.push("danger-full-access");
+    }
+    const start = Date.now();
+    const proc = spawn("codex", [...args, prompt], {
+      cwd,
+      env: { ...process.env, NO_COLOR: "1" },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Codex CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (code !== 0 && code !== null) {
+        rmSync(tempDir, { recursive: true, force: true });
+        reject(new Error(`Codex CLI exited with code ${code}\nstderr: ${stderr}`));
+        return;
+      }
+
+      let text = stdout.trim();
+      try {
+        const lastMessage = readFileSync(outputFile, "utf8").trim();
+        if (lastMessage) text = lastMessage;
+      } catch {
+        // Fall back to raw stdout when the output file is missing.
+      } finally {
+        rmSync(tempDir, { recursive: true, force: true });
+      }
+
+      resolve({
+        text,
+        raw: stdout,
+        elapsed: Date.now() - start,
+      });
+    });
+
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      rmSync(tempDir, { recursive: true, force: true });
+      reject(err);
+    });
+  });
+}
+
+function executeClaude(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const {
+    model,
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = ["-p", prompt];
+    if (model) {
+      args.push("--model");
+      args.push(model);
+    }
+    if (yolo) {
+      args.push("--permission-mode");
+      args.push("bypassPermissions");
+    }
+
+    const start = Date.now();
+    const proc = spawn("claude", args, {
+      cwd,
+      env: { ...process.env, NO_COLOR: "1" },
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Claude CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Claude CLI exited with code ${code}\nstderr: ${stderr}`));
+        return;
+      }
+
+      resolve({
+        text: stdout.trim(),
+        raw: stdout,
+        elapsed: Date.now() - start,
+      });
+    });
+
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+// ── 注册表（新增 CLI 工具时在这里加） ────────────────────────────────────────
+
+const EXECUTORS: Record<
+  CliProvider,
+  (prompt: string, options: CliExecuteOptions) => Promise<CliExecuteResult>
+> = {
+  copilot: executeCopilot,
+  gemini: executeGemini,
+  codex: executeCodex,
+  claude: executeClaude,
+};
+
+function formatCliSessionTask(messages: CliSessionMessage[]): string {
+  return messages
+    .map((message, index) => {
+      const speaker = message.role === "user" ? "用户" : "助手";
+      return `[${index + 1}] ${speaker}\n${message.content.trim()}`;
+    })
+    .join("\n\n");
+}
+
+function buildCliSessionPrompt(session: CliSessionState, userInput: string): string {
+  const transcript = formatCliSessionTask([
+    ...session.messages,
+    { role: "user", content: userInput },
+  ]);
+
+  return buildCliPrompt(
+    session.systemPrompt,
+    [
+      "以下是当前对话，请基于完整上下文继续回答最后一条用户消息。",
+      transcript,
+    ].join("\n\n"),
+  );
+}
+
+function getCliSessionOrThrow(sessionId: string): CliSessionState {
+  const session = cliSessions.get(sessionId);
+  if (!session) {
+    throw new Error(`Unknown CLI session: "${sessionId}"`);
+  }
+  return session;
+}
+
+// ── 公开 API ──────────────────────────────────────────────────────────────────
+
+/**
+ * 执行 CLI 任务
+ *
+ * @param provider  CLI 工具类型（如 "copilot" | "gemini" | "codex" | "claude"）
+ * @param prompt    完整 prompt（system prompt 已由调用方拼好）
+ * @param options   执行选项
+ */
+export async function executeCli(
+  provider: CliProvider,
+  prompt: string,
+  options: CliExecuteOptions = {}
+): Promise<CliExecuteResult> {
+  const executor = EXECUTORS[provider];
+  if (!executor) {
+    throw new Error(`Unknown CLI provider: "${provider}". Supported: ${Object.keys(EXECUTORS).join(", ")}`);
+  }
+  return executor(prompt, options);
+}
+
+export { buildCliPrompt };
+
+export function startCliSession(
+  provider: CliProvider,
+  options: CliExecuteOptions & { systemPrompt?: string } = {},
+): CliSessionHandle {
+  if (!EXECUTORS[provider]) {
+    throw new Error(`Unknown CLI provider: "${provider}". Supported: ${Object.keys(EXECUTORS).join(", ")}`);
+  }
+
+  const sessionId = randomUUID();
+  cliSessions.set(sessionId, {
+    sessionId,
+    provider,
+    systemPrompt: options.systemPrompt,
+    options: {
+      model: options.model,
+      timeout: options.timeout,
+      cwd: options.cwd,
+      yolo: options.yolo,
+    },
+    messages: [],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  });
+
+  return { sessionId, provider };
+}
+
+export function getCliSession(sessionId: string): CliSessionState | null {
+  return cliSessions.get(sessionId) ?? null;
+}
+
+export function closeCliSession(sessionId: string): boolean {
+  return cliSessions.delete(sessionId);
+}
+
+export async function executeCliSessionTurn(
+  sessionId: string,
+  userInput: string,
+  options: Partial<CliExecuteOptions> = {},
+): Promise<CliSessionTurnResult> {
+  const trimmedInput = userInput.trim();
+  if (!trimmedInput) {
+    throw new Error("CLI session turn requires non-empty user input.");
+  }
+
+  const session = getCliSessionOrThrow(sessionId);
+  const prompt = buildCliSessionPrompt(session, trimmedInput);
+  const result = await executeCli(session.provider, prompt, {
+    ...session.options,
+    ...options,
+  });
+
+  session.messages.push(
+    { role: "user", content: trimmedInput },
+    { role: "assistant", content: result.text },
+  );
+  session.updatedAt = Date.now();
+
+  return {
+    ...result,
+    sessionId: session.sessionId,
+  };
+}
+
+export async function executeCliSessionTurnStreaming(
+  sessionId: string,
+  userInput: string,
+  options: Partial<CliExecuteOptions> & { onChunk: (chunk: string) => void },
+): Promise<CliSessionTurnResult> {
+  const trimmedInput = userInput.trim();
+  if (!trimmedInput) {
+    throw new Error("CLI session turn requires non-empty user input.");
+  }
+
+  const session = getCliSessionOrThrow(sessionId);
+  const prompt = buildCliSessionPrompt(session, trimmedInput);
+  const result = await executeCliStreaming(session.provider, prompt, {
+    ...session.options,
+    ...options,
+  });
+
+  session.messages.push(
+    { role: "user", content: trimmedInput },
+    { role: "assistant", content: result.text },
+  );
+  session.updatedAt = Date.now();
+
+  return {
+    ...result,
+    sessionId: session.sessionId,
+  };
+}
+
+/** 忽略 gh 版本更新提示行 */
+function filterNoiseLine(line: string): boolean {
+  return (
+    !line.includes("A new release of gh is available") &&
+    !line.includes("To upgrade, run:") &&
+    !line.includes("https://github.com/cli/cli/releases")
+  );
+}
+
+/**
+ * 流式执行 Copilot CLI，通过 onChunk 回调逐块返回输出
+ * 使用 spawn 替代 exec，不缓冲 stdout
+ */
+export function executeCliStreaming(
+  provider: CliProvider,
+  prompt: string,
+  options: CliExecuteOptions & { onChunk: (chunk: string) => void }
+): Promise<CliExecuteResult> {
+  if (provider === "gemini") {
+    return executeGeminiStreaming(prompt, options);
+  }
+  if (provider === "codex") {
+    return executeCli(provider, prompt, options).then((result) => {
+      if (result.text) options.onChunk(result.text);
+      return result;
+    });
+  }
+  if (provider === "claude") {
+    return executeCli(provider, prompt, options).then((result) => {
+      if (result.text) options.onChunk(result.text);
+      return result;
+    });
+  }
+  if (provider !== "copilot") {
+    return executeCli(provider, prompt, options);
+  }
+
+  const { model, timeout = 120_000, cwd = process.cwd(), yolo = true, onChunk } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      "copilot", "--",
+      "-p", prompt,
+      "--silent",
+      "--disable-builtin-mcps",
+    ];
+    if (model) { args.push("--model"); args.push(model); }
+    if (yolo) args.push("--yolo");
+
+    const start = Date.now();
+    const proc = spawn("gh", args, {
+      cwd,
+      env: { ...process.env, NO_COLOR: "1" },
+    });
+
+    let raw = "";
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Copilot CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout.on("data", (data: Buffer) => {
+      const chunk = data.toString();
+      raw += chunk;
+      // 过滤噪音行后再推送
+      const cleaned = chunk
+        .split("\n")
+        .filter(filterNoiseLine)
+        .join("\n");
+      if (cleaned) onChunk(cleaned);
+    });
+
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Copilot CLI exited with code ${code}`));
+        return;
+      }
+      const text = raw
+        .split("\n")
+        .filter(filterNoiseLine)
+        .join("\n")
+        .trim();
+      resolve({ text, raw, elapsed: Date.now() - start });
+    });
+
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+function executeGeminiStreaming(
+  prompt: string,
+  options: CliExecuteOptions & { onChunk: (chunk: string) => void }
+): Promise<CliExecuteResult> {
+  const {
+    model = "gemini-3-flash-preview",
+    timeout = 120_000,
+    cwd = process.cwd(),
+    yolo = true,
+    onChunk,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const args = ["-p", prompt, "--output-format", "stream-json", "-m", model];
+    if (yolo) args.push("--yolo");
+    args.push("-e", "none");
+
+    const start = Date.now();
+    const proc = spawn("gemini", args, {
+      cwd,
+      env: { ...process.env, NO_COLOR: "1", NODE_OPTIONS: "--no-deprecation" },
+    });
+
+    let raw = "";
+    let stderr = "";
+    let lineBuffer = "";
+    let timer: ReturnType<typeof setTimeout> | undefined;
+
+    const flushLineBuffer = () => {
+      const trimmed = lineBuffer.trim();
+      if (!trimmed) return;
+      try {
+        const event = JSON.parse(trimmed);
+        const text = extractGeminiEventText(event);
+        if (text) onChunk(text);
+      } catch {
+        // ignore partial or malformed lines
+      }
+      lineBuffer = "";
+    };
+
+    if (timeout > 0) {
+      timer = setTimeout(() => {
+        proc.kill("SIGTERM");
+        reject(new Error(`Gemini CLI timed out after ${timeout}ms`));
+      }, timeout);
+    }
+
+    proc.stdout.on("data", (data: Buffer) => {
+      const chunk = data.toString();
+      raw += chunk;
+      lineBuffer += chunk;
+
+      let newlineIndex = lineBuffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = lineBuffer.slice(0, newlineIndex).trim();
+        lineBuffer = lineBuffer.slice(newlineIndex + 1);
+        if (line) {
+          try {
+            const event = JSON.parse(line);
+            const text = extractGeminiEventText(event);
+            if (text) onChunk(text);
+          } catch {
+            // ignore malformed lines
+          }
+        }
+        newlineIndex = lineBuffer.indexOf("\n");
+      }
+    });
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      flushLineBuffer();
+
+      if (code !== 0 && code !== null) {
+        reject(new Error(`Gemini CLI exited with code ${code}\nstderr: ${stderr}`));
+        return;
+      }
+
+      resolve({
+        text: parseGeminiStreamJson(raw),
+        raw,
+        elapsed: Date.now() - start,
+      });
+    });
+
+    proc.on("error", (err) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}

package/ai/agent/cliPrompt.ts

@@ -0,0 +1,10 @@
+/**
+ * 构建包含 system prompt 的完整 prompt。
+ *
+ * CLI agent 与普通 model 共用 prompt / model / 最近文本上下文这些能力面，
+ * 但 CLI 不走本地 tool-calls 协议，因此这里只做文本级结构化拼接。
+ */
+export function buildCliPrompt(systemPrompt: string | undefined, taskPrompt: string): string {
+  if (!systemPrompt?.trim()) return taskPrompt;
+  return `[角色设定]\n${systemPrompt.trim()}\n\n[当前任务]\n${taskPrompt.trim()}`;
+}

package/ai/agent/machineRunPermissions.ts

@@ -0,0 +1,95 @@
+export type MachineRunPermissionMode = "read_only" | "full_access";
+
+export type MachineRunPermissionPolicy = {
+  mode: MachineRunPermissionMode;
+  allowFilesystemRead: boolean;
+  allowFilesystemWrite: boolean;
+  allowShell: boolean;
+  writableRoots: string[];
+};
+
+const DEFAULT_POLICY: MachineRunPermissionPolicy = {
+  mode: "read_only",
+  allowFilesystemRead: true,
+  allowFilesystemWrite: false,
+  allowShell: false,
+  writableRoots: [],
+};
+
+const WRITE_DENIED =
+  "Machine permission denied: this bound machine agent is read-only for filesystem writes. Enable machine write permission for this agent before asking it to modify files.";
+
+const SHELL_DENIED =
+  "Machine permission denied: this bound machine agent cannot run arbitrary shell commands. Enable machine shell permission for this agent before asking it to execute commands.";
+
+function asObject(value: unknown): Record<string, any> {
+  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, any> : {};
+}
+
+function normalizeWritableRoots(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter((item): item is string => typeof item === "string")
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+export function resolveMachineRunPermissionPolicy(agentConfig: any): MachineRunPermissionPolicy {
+  const runtimeBinding = asObject(agentConfig?.runtimeBinding);
+  const raw = asObject(
+    agentConfig?.machinePermissions ??
+      runtimeBinding.permissions ??
+      runtimeBinding.machinePermissions ??
+      agentConfig?.boundRuntimeMachine?.permissions
+  );
+
+  const mode: MachineRunPermissionMode =
+    raw.mode === "full_access" || raw.allowFilesystemWrite === true || raw.allowShell === true
+      ? "full_access"
+      : "read_only";
+
+  if (mode === "full_access") {
+    return {
+      mode,
+      allowFilesystemRead: raw.allowFilesystemRead !== false,
+      allowFilesystemWrite: true,
+      allowShell: raw.allowShell !== false,
+      writableRoots: normalizeWritableRoots(raw.writableRoots),
+    };
+  }
+
+  return {
+    ...DEFAULT_POLICY,
+    allowFilesystemRead: raw.allowFilesystemRead !== false,
+  };
+}
+
+const WRITE_INTENT_RE =
+  /\b(write|overwrite|edit|modify|delete|remove|rename|move|create|save|patch|apply patch|mkdir|touch|rm|rmdir|del|erase|copy-item|move-item|remove-item|set-content|add-content|new-item)\b|[\u5199\u5220\u6539\u4FEE\u4FDD\u5B58\u521B\u5EFA\u79FB\u52A8]/i;
+
+const SHELL_INTENT_RE =
+  /\b(run|execute|exec|shell|terminal|powershell|pwsh|bash|zsh|cmd\.exe|npm|bun|node|python|git|curl|wget|ssh|scp|chmod|chown|sudo)\b|[\u8FD0\u884C\u6267\u884C\u547D\u4EE4\u7EC8\u7AEF]/i;
+
+export function assertMachineRunAllowed(userInput: string, policy: MachineRunPermissionPolicy) {
+  const task = String(userInput || "");
+  if (!policy.allowFilesystemWrite && WRITE_INTENT_RE.test(task)) {
+    throw new Error(WRITE_DENIED);
+  }
+  if (!policy.allowShell && SHELL_INTENT_RE.test(task)) {
+    throw new Error(SHELL_DENIED);
+  }
+}
+
+export function buildMachinePermissionPromptBlock(policy: MachineRunPermissionPolicy) {
+  return [
+    "--- Machine permission policy ---",
+    `Mode: ${policy.mode}`,
+    `Filesystem reads are ${policy.allowFilesystemRead ? "allowed" : "not allowed"}.`,
+    `File writes are ${policy.allowFilesystemWrite ? "allowed" : "not allowed"}.`,
+    `Arbitrary shell commands are ${policy.allowShell ? "allowed" : "not allowed"}.`,
+    policy.writableRoots.length
+      ? `Writable roots: ${policy.writableRoots.join(", ")}`
+      : "Writable roots: none.",
+    "If the user asks for an operation outside this policy, refuse instead of attempting it.",
+  ].join("\n");
+}

package/client/compactDialog.ts

@@ -0,0 +1,219 @@
+// packages/cli/client/compactDialog.ts
+// HTTP-only compact helper for CLI TUI (no Redux store available).
+
+import { ulid } from "ulid";
+
+const DB_PATH = "/api/v1/db";
+
+/**
+ * Extract userId from a JWT-style auth token without verifying the signature.
+ * Mirrors the logic of `parseToken` in `auth/token.ts` without the crypto imports.
+ */
+function parseTokenUserId(token: string): string | null {
+  try {
+    const [payloadBase64] = token.split(".");
+    const payload = JSON.parse(
+      Buffer.from(payloadBase64, "base64").toString("utf8")
+    );
+    return typeof payload?.userId === "string" ? payload.userId : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract the custom ID (ULID) from a dialog key like `dialog-{userId}-{id}`.
+ * Mirrors `extractCustomId` from `core/prefix` without importing it.
+ */
+function extractCustomId(key: string): string {
+  const parts = key.split("-");
+  return parts.slice(2).join("-");
+}
+
+async function readDialogRecord(
+  fetchImpl: typeof fetch,
+  serverUrl: string,
+  authToken: string,
+  dialogKey: string
+): Promise<Record<string, unknown>> {
+  const res = await fetchImpl(`${serverUrl}${DB_PATH}/read/${dialogKey}`, {
+    headers: { Authorization: `Bearer ${authToken}` },
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to read dialog "${dialogKey}": HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  return data as Record<string, unknown>;
+}
+
+/**
+ * Fields carried forward from the source dialog into the fork.
+ * Conversation summary/compression state is intentionally excluded so the new
+ * dialog starts clean: summary, summarizedBeforeId, proactiveSummary,
+ * proactiveSummaryBeforeId, compressionCount, summaryPending must NOT be
+ * inherited — they describe the old conversation, not the fork.
+ */
+const FORKED_CARRY_FIELDS = [
+  "cybots",
+  "type",
+  "title",
+  "spaceId",
+  "category",
+  "referenceKeys",
+  "triggerType",
+  "schedule",
+  "taskPrompt",
+  "executionMode",
+] as const;
+
+function buildForkedDialogRecord(
+  current: Record<string, unknown>,
+  userId: string
+): Record<string, unknown> & { dbKey: string; id: string } {
+  const newId = ulid();
+  const dbKey = `dialog-${userId}-${newId}`;
+  const now = new Date().toISOString();
+
+  // Explicitly pick only the allowed fields — never spread `current` wholesale.
+  const carried: Record<string, unknown> = {};
+  for (const field of FORKED_CARRY_FIELDS) {
+    if (current[field] !== undefined) {
+      carried[field] = current[field];
+    }
+  }
+
+  return {
+    ...carried,
+    id: newId,
+    dbKey,
+    inheritedFromDialogKey: current.dbKey,
+    inheritedFromDialogTitle: current.title,
+    createdAt: now,
+    updatedAt: now,
+    // reset per-dialog stats
+    inputTokens: 0,
+    outputTokens: 0,
+    totalCost: 0,
+  };
+}
+
+async function writeDialogRecord(
+  fetchImpl: typeof fetch,
+  serverUrl: string,
+  authToken: string,
+  record: Record<string, unknown> & { dbKey: string }
+): Promise<void> {
+  const res = await fetchImpl(`${serverUrl}${DB_PATH}/write/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authToken}`,
+    },
+    body: JSON.stringify({ data: record, customKey: record.dbKey }),
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Failed to write forked dialog "${record.dbKey}": HTTP ${res.status}`
+    );
+  }
+}
+
+/**
+ * Best-effort: register the forked dialog in the space sidebar.
+ * Failure here is non-fatal since the dialog is already stored.
+ */
+async function addDialogToSpaceIfNeeded(
+  fetchImpl: typeof fetch,
+  serverUrl: string,
+  authToken: string,
+  record: Record<string, unknown> & { dbKey: string }
+): Promise<void> {
+  const rawSpaceId = record.spaceId;
+  if (!rawSpaceId || typeof rawSpaceId !== "string") return;
+
+  const normalizedSpaceId = rawSpaceId.startsWith("space-")
+    ? rawSpaceId.slice("space-".length)
+    : rawSpaceId;
+  const spaceKey = `space-${normalizedSpaceId}`;
+  const now = Date.now();
+
+  const contentEntry = {
+    title: typeof record.title === "string" ? record.title : record.id,
+    type: "dialog",
+    contentKey: record.dbKey,
+    pinned: false,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  try {
+    const res = await fetchImpl(`${serverUrl}${DB_PATH}/patch/${spaceKey}`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authToken}`,
+      },
+      body: JSON.stringify({ contents: { [record.dbKey]: contentEntry } }),
+    });
+    if (!res.ok) {
+      console.warn(
+        `[nolo] compact: addDialogToSpace failed for ${spaceKey}: HTTP ${res.status}`
+      );
+    }
+  } catch (error) {
+    console.warn(`[nolo] compact: addDialogToSpace error: ${error}`);
+  }
+}
+
+export type CompactDialogResult = {
+  dialogId: string;
+  dialogKey: string;
+  spaceId?: string;
+};
+
+/**
+ * Compact the current dialog by forking it:
+ * 1. Read the current dialog config from the server.
+ * 2. Build a new dialog record that inherits from the old one.
+ * 3. Write the new record to the server.
+ * 4. Register the new dialog in the space sidebar (best-effort).
+ *
+ * Returns the new dialog's ID so the TUI can switch to it.
+ */
+export async function compactDialog(options: {
+  serverUrl: string;
+  authToken: string;
+  dialogId: string;
+  fetchImpl?: typeof fetch;
+}): Promise<CompactDialogResult> {
+  const fetchImpl = options.fetchImpl ?? fetch;
+
+  const userId = parseTokenUserId(options.authToken);
+  if (!userId) {
+    throw new Error(
+      "[nolo] compact: cannot compact — invalid or missing auth token"
+    );
+  }
+
+  const dialogKey = `dialog-${userId}-${options.dialogId}`;
+  const current = await readDialogRecord(
+    fetchImpl,
+    options.serverUrl,
+    options.authToken,
+    dialogKey
+  );
+  const next = buildForkedDialogRecord(current, userId);
+  await writeDialogRecord(fetchImpl, options.serverUrl, options.authToken, next);
+  await addDialogToSpaceIfNeeded(
+    fetchImpl,
+    options.serverUrl,
+    options.authToken,
+    next
+  );
+
+  return {
+    dialogId: extractCustomId(next.dbKey),
+    dialogKey: next.dbKey,
+    spaceId: typeof next.spaceId === "string" ? next.spaceId : undefined,
+  };
+}

package/connector-experimental/capabilities.ts

@@ -0,0 +1,73 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveLaunchableCodexCommand } from "./codexBinary";
+
+type EnvLike = Record<string, string | undefined>;
+
+type DetectRuntimeCapabilitiesOptions = {
+  commandExists?: (command: string) => boolean;
+  commandLaunchable?: (command: string, args: string[]) => boolean;
+  env?: EnvLike;
+  probeLaunchable?: boolean;
+};
+
+type CommandProbe = {
+  command: string;
+  args: string[];
+};
+
+const COMMAND_CAPABILITIES: Array<[probes: CommandProbe[], capability: string]> = [
+  [[{ command: "codex", args: ["--version"] }], "codex-cli"],
+  [[{ command: "claude", args: ["--version"] }], "claude-code"],
+  [
+    [
+      { command: "gh", args: ["--version"] },
+      { command: "gh", args: ["copilot", "--", "--help"] },
+    ],
+    "copilot-cli",
+  ],
+  [[{ command: "gemini", args: ["--version"] }], "gemini-cli"],
+  [[{ command: "kimi", args: ["--version"] }], "kimi-cli"],
+];
+
+function defaultCommandExists(command: string) {
+  const pathEntries = (process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
+  const extensions = process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+  return pathEntries.some((entry) =>
+    extensions.some((extension) => existsSync(join(entry, `${command}${extension}`)))
+  );
+}
+
+function defaultCommandLaunchable(command: string, args: string[]) {
+  const executable = command === "codex" ? resolveLaunchableCodexCommand() : command;
+  const result = spawnSync(executable, args, {
+    stdio: "pipe",
+    timeout: 3_000,
+    windowsHide: true,
+  });
+  return !result.error && result.status === 0;
+}
+
+export function detectRuntimeCapabilities(
+  options: DetectRuntimeCapabilitiesOptions = {}
+): string[] {
+  const commandExists = options.commandExists ?? defaultCommandExists;
+  const commandLaunchable = options.commandLaunchable ?? defaultCommandLaunchable;
+  const env = options.env ?? process.env;
+  const capabilities: string[] = [];
+
+  for (const [probes, capability] of COMMAND_CAPABILITIES) {
+    if (!probes.every((probe) => commandExists(probe.command))) continue;
+    if (options.probeLaunchable && !probes.every((probe) => commandLaunchable(probe.command, probe.args))) {
+      continue;
+    }
+    capabilities.push(capability);
+  }
+
+  if (env.NOLO_LOCAL_LLM_ENDPOINT || env.LLAMA_SERVER_URL) {
+    capabilities.push("local-llm");
+  }
+
+  return capabilities;
+}

package/connector-experimental/codexBinary.ts

@@ -0,0 +1,41 @@
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+type EnvLike = Record<string, string | undefined>;
+
+const WINDOWS_APPS_CODEX_PATTERN = /\\WindowsApps\\OpenAI\.Codex_[^\\]+\\app\\resources$/i;
+
+function pathEntries(env: EnvLike) {
+  return (env.PATH ?? process.env.PATH ?? "").split(process.platform === "win32" ? ";" : ":");
+}
+
+function findWindowsAppsCodex(env: EnvLike) {
+  if (process.platform !== "win32") return "";
+  for (const entry of pathEntries(env)) {
+    if (!WINDOWS_APPS_CODEX_PATTERN.test(entry)) continue;
+    const candidate = join(entry, "codex.exe");
+    if (existsSync(candidate)) return candidate;
+  }
+  return "";
+}
+
+function copyCodexToUserBin(source: string, env: EnvLike) {
+  const target =
+    env.NOLO_CODEX_SHIM_PATH ??
+    join(homedir(), ".nolo", "bin", "codex.exe");
+  if (existsSync(target)) return target;
+  mkdirSync(dirname(target), { recursive: true });
+  copyFileSync(source, target);
+  return target;
+}
+
+export function resolveLaunchableCodexCommand(env: EnvLike = process.env) {
+  const explicit = env.NOLO_CODEX_BIN?.trim();
+  if (explicit) return explicit;
+
+  const windowsAppsCodex = findWindowsAppsCodex(env);
+  if (windowsAppsCodex) return copyCodexToUserBin(windowsAppsCodex, env);
+
+  return "codex";
+}

package/connector-experimental/heartbeatLoop.ts

@@ -0,0 +1,22 @@
+export type HeartbeatLoopOptions = {
+  intervalMs: number;
+  sendHeartbeat: () => Promise<void>;
+  sleep?: (ms: number) => Promise<void>;
+  signal?: AbortSignal;
+  maxBeats?: number;
+};
+
+const defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+export async function runHeartbeatLoop(options: HeartbeatLoopOptions): Promise<void> {
+  const sleep = options.sleep ?? defaultSleep;
+  let beats = 0;
+
+  while (!options.signal?.aborted) {
+    await options.sendHeartbeat();
+    beats += 1;
+    if (options.maxBeats && beats >= options.maxBeats) return;
+    if (options.signal?.aborted) return;
+    await sleep(options.intervalMs);
+  }
+}

package/connector-experimental/machineInfo.ts

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { arch, hostname, homedir, platform } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { detectRuntimeCapabilities } from "./capabilities";
+import type { MachineHeartbeat } from "./protocol";
+
+const CONNECTOR_VERSION = "0.1.0-experimental";
+
+function defaultMachineIdPath() {
+  return join(homedir(), ".nolo", "machine-id");
+}
+
+export function resolveMachineId(path = defaultMachineIdPath()) {
+  try {
+    if (existsSync(path)) {
+      const existing = readFileSync(path, "utf8").trim();
+      if (existing) return existing;
+    }
+    const next = `machine-${randomUUID()}`;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${next}\n`, "utf8");
+    return next;
+  } catch {
+    return `machine-${hostname().toLowerCase()}`;
+  }
+}
+
+export function detectMachineInfo(overrides?: {
+  machineId?: string;
+  name?: string;
+  capabilities?: string[];
+  probeLaunchable?: boolean;
+}): MachineHeartbeat {
+  return {
+    machineId: overrides?.machineId ?? resolveMachineId(),
+    name: overrides?.name ?? hostname(),
+    platform: platform(),
+    arch: arch(),
+    connectorVersion: CONNECTOR_VERSION,
+    capabilities: overrides?.capabilities ?? detectRuntimeCapabilities({
+      probeLaunchable: overrides?.probeLaunchable,
+    }),
+  };
+}

package/connector-experimental/protocol.ts

@@ -0,0 +1,54 @@
+export type MachineHeartbeatInput = {
+  machineId?: unknown;
+  name?: unknown;
+  platform?: unknown;
+  arch?: unknown;
+  connectorVersion?: unknown;
+  capabilities?: unknown;
+};
+
+export type MachineHeartbeat = {
+  machineId: string;
+  name: string;
+  platform: string;
+  arch: string;
+  connectorVersion?: string;
+  capabilities: string[];
+};
+
+const normalizeRequiredString = (value: unknown, field: string) => {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${field} is required`);
+  }
+  return value.trim();
+};
+
+const normalizeOptionalString = (value: unknown) =>
+  typeof value === "string" && value.trim() ? value.trim() : undefined;
+
+export function normalizeCapabilityList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const item of value) {
+    if (typeof item !== "string") continue;
+    const normalized = item.trim();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+
+export function normalizeMachineHeartbeat(input: MachineHeartbeatInput): MachineHeartbeat {
+  const heartbeat: MachineHeartbeat = {
+    machineId: normalizeRequiredString(input.machineId, "machineId"),
+    name: normalizeRequiredString(input.name, "name"),
+    platform: normalizeRequiredString(input.platform, "platform"),
+    arch: normalizeRequiredString(input.arch, "arch"),
+    capabilities: normalizeCapabilityList(input.capabilities),
+  };
+  const connectorVersion = normalizeOptionalString(input.connectorVersion);
+  if (connectorVersion) heartbeat.connectorVersion = connectorVersion;
+  return heartbeat;
+}

package/machineCommands.ts

@@ -1,5 +1,5 @@
-import type { MachineHeartbeat } from "connector-experimental/protocol";
-import { detectMachineInfo } from "connector-experimental/machineInfo";
+import type { MachineHeartbeat } from "./connector-experimental/protocol";
+import { detectMachineInfo } from "./connector-experimental/machineInfo";
 import { mkdirSync, openSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -7,12 +7,12 @@ import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import {
   type HeartbeatLoopOptions,
   runHeartbeatLoop as defaultRunHeartbeatLoop,
-} from "connector-experimental/heartbeatLoop";
+} from "./connector-experimental/heartbeatLoop";
 import {
   assertMachineRunAllowed,
   buildMachinePermissionPromptBlock,
   resolveMachineRunPermissionPolicy,
-} from "../ai/agent/machineRunPermissions";
+} from "./ai/agent/machineRunPermissions";
 import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
 
 type EnvLike = Record<string, string | undefined>;
@@ -161,7 +161,7 @@ async function defaultConnectWebSocket(url: string, options: ConnectorWebSocketO
 }
 
 async function defaultExecuteCli(provider: string, prompt: string, options: { model?: string; yolo?: boolean }) {
-  const { executeCli } = await import("ai/agent/cliExecutor");
+  const { executeCli } = await import("./ai/agent/cliExecutor");
   return executeCli(provider as any, prompt, options);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -16,21 +16,17 @@
     "defaultServer.ts",
     "machineCommands.ts",
     "updateCommands.ts",
-    "client/agentRun.ts",
-    "client/profileConfig.ts",
-    "tui/readlineWorkspace.ts",
-    "tui/session.ts",
-    "README.md"
+    "client/**/*.ts",
+    "tui/**/*.ts",
+    "README.md",
+    "ai/**/*.ts",
+    "connector-experimental/**/*.ts"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "devDependencies": {
-    "bun-types": "latest"
-  },
   "dependencies": {
-    "ai": "workspace:*",
-    "connector-experimental": "workspace:*"
+    "ulid": "^2.3.0"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"