nolo-cli 0.1.7 → 0.1.9

package/machineCommands.ts

@@ -0,0 +1,382 @@
+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";
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import {
+  type HeartbeatLoopOptions,
+  runHeartbeatLoop as defaultRunHeartbeatLoop,
+} from "./connector-experimental/heartbeatLoop";
+import {
+  assertMachineRunAllowed,
+  buildMachinePermissionPromptBlock,
+  resolveMachineRunPermissionPolicy,
+} from "./ai/agent/machineRunPermissions";
+import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
+
+type EnvLike = Record<string, string | undefined>;
+type OutputLike = { write(chunk: string): unknown };
+type ConnectorWebSocketOptions = {
+  headers: Record<string, string>;
+  onMessage: (message: string) => void | Promise<void>;
+  sentMessages: string[];
+};
+type LocalCliExecutor = (
+  provider: string,
+  prompt: string,
+  options: { model?: string; yolo?: boolean }
+) => Promise<{ text: string; raw?: string; elapsed?: number }>;
+
+export type MachineSummary = {
+  machineId: string;
+  name: string;
+  platform: string;
+  arch: string;
+  connectorVersion: string | null;
+  capabilities: string[];
+  connectorStatus?: "connected" | "disconnected";
+  status: "online" | "offline";
+  lastSeenAt: number;
+};
+
+type MachineCommandDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  fetchImpl?: typeof fetch;
+  machineInfo?: () => MachineHeartbeat;
+  runHeartbeatLoop?: (options: HeartbeatLoopOptions) => Promise<void>;
+  connectWebSocket?: (url: string, options: ConnectorWebSocketOptions) => Promise<void>;
+  executeCli?: LocalCliExecutor;
+  spawnDaemon?: (args: {
+    cmd: string[];
+    cwd: string;
+    env: EnvLike;
+    logPath: string;
+  }) => { pid?: number };
+};
+
+function resolveServerUrl(env: EnvLike) {
+  return (env.NOLO_SERVER || env.BASE_URL || DEFAULT_NOLO_SERVER_URL).replace(/\/+$/, "");
+}
+
+function resolveAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || "";
+}
+
+function writeAuthMissing(output: OutputLike) {
+  output.write(
+    "[nolo] Machine commands require an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
+  );
+}
+
+function hasFlag(args: string[], flag: string) {
+  return args.includes(flag);
+}
+
+function resolveDaemonLogPath(env: EnvLike) {
+  return env.NOLO_CONNECT_LOG || join(homedir(), ".nolo", "logs", "connector.log");
+}
+
+function defaultSpawnDaemon(args: {
+  cmd: string[];
+  cwd: string;
+  env: EnvLike;
+  logPath: string;
+}) {
+  mkdirSync(dirname(args.logPath), { recursive: true });
+  const out = openSync(args.logPath, "a");
+  const env = Object.fromEntries(
+    Object.entries(args.env).filter((entry): entry is [string, string] => typeof entry[1] === "string")
+  );
+  const proc = Bun.spawn({
+    cmd: args.cmd,
+    cwd: args.cwd,
+    env,
+    stdin: "ignore",
+    stdout: out,
+    stderr: out,
+  });
+  proc.unref();
+  return { pid: proc.pid };
+}
+
+function resolveHeartbeatIntervalMs(env: EnvLike) {
+  const raw = Number(env.NOLO_CONNECT_HEARTBEAT_MS ?? "");
+  return Number.isFinite(raw) && raw > 0 ? raw : 30_000;
+}
+
+async function defaultConnectWebSocket(url: string, options: ConnectorWebSocketOptions) {
+  const WebSocketCtor = globalThis.WebSocket;
+  if (!WebSocketCtor) {
+    throw new Error("WebSocket is not available in this runtime");
+  }
+  await new Promise<void>((resolve, reject) => {
+    const ws = new WebSocketCtor(url, {
+      headers: options.headers,
+    } as any);
+    let opened = false;
+    ws.addEventListener("open", () => {
+      opened = true;
+    }, { once: true });
+    ws.addEventListener("error", () => reject(new Error("connector websocket failed")));
+    ws.addEventListener("close", () => {
+      if (opened) resolve();
+      else reject(new Error("connector websocket closed before opening"));
+    }, { once: true });
+    ws.addEventListener("message", (event) => {
+      const startIndex = options.sentMessages.length;
+      Promise.resolve(options.onMessage(String(event.data))).then(() => {
+        for (const message of options.sentMessages.slice(startIndex)) {
+          ws.send(message);
+        }
+      }).catch(() => undefined);
+    });
+  });
+}
+
+async function defaultExecuteCli(provider: string, prompt: string, options: { model?: string; yolo?: boolean }) {
+  const { executeCli } = await import("ai/agent/cliExecutor");
+  return executeCli(provider as any, prompt, options);
+}
+
+function detectLaunchableMachineInfo() {
+  return detectMachineInfo({ probeLaunchable: true });
+}
+
+function buildConnectorCliPrompt(agentConfig: any, userInput: string) {
+  const policy = resolveMachineRunPermissionPolicy(agentConfig);
+  return [
+    typeof agentConfig?.prompt === "string" ? agentConfig.prompt.trim() : "",
+    buildMachinePermissionPromptBlock(policy),
+    `--- User task ---\n${userInput}`,
+  ].filter(Boolean).join("\n\n");
+}
+
+async function handleConnectorRunMessage(
+  machine: MachineHeartbeat,
+  message: string,
+  send: (message: string) => void,
+  executeCli: LocalCliExecutor
+) {
+  let parsed: any;
+  try {
+    parsed = JSON.parse(message);
+  } catch {
+    return;
+  }
+  if (parsed?.type !== "agent.run" || typeof parsed.requestId !== "string") return;
+  const agentConfig = parsed.payload?.agentConfig ?? {};
+  try {
+    if (agentConfig.apiSource !== "cli") {
+      throw new Error("Connector can only execute CLI agents. Set the agent apiSource to cli and choose a cliProvider.");
+    }
+    const provider = String(agentConfig.cliProvider || "copilot");
+    const policy = resolveMachineRunPermissionPolicy(agentConfig);
+    const userInput = String(parsed.payload?.userInput ?? "");
+    assertMachineRunAllowed(userInput, policy);
+    const result = await executeCli(
+      provider,
+      buildConnectorCliPrompt(agentConfig, userInput),
+      {
+        model: agentConfig.model || undefined,
+        yolo: true,
+      }
+    );
+    send(JSON.stringify({
+      type: "agent.run.result",
+      requestId: parsed.requestId,
+      result: {
+        content: result.text,
+        model: agentConfig.model ?? provider,
+        trace: [{ role: "assistant", content: result.text }],
+      },
+    }));
+  } catch (error) {
+    send(JSON.stringify({
+      type: "agent.run.result",
+      requestId: parsed.requestId,
+      error: error instanceof Error ? error.message : String(error),
+    }));
+  }
+}
+
+export function formatMachineStatus(machines: MachineSummary[]) {
+  if (machines.length === 0) {
+    return "No connected machines.\nRun `nolo connect` on this computer to register it once.\n";
+  }
+
+  return [
+    "Connected machines:",
+    ...machines.map((machine) => {
+      const caps = machine.capabilities.length ? machine.capabilities.join(", ") : "no capabilities";
+      const connector = machine.connectorStatus ? `  ws:${machine.connectorStatus}` : "";
+      return `- ${machine.name}  ${machine.status}${connector}  ${machine.platform}/${machine.arch}  ${caps}`;
+    }),
+    "",
+  ].join("\n");
+}
+
+export async function runMachineConnectCommand(
+  args: string[],
+  deps: MachineCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const authToken = resolveAuthToken(env);
+  if (!authToken) {
+    writeAuthMissing(output);
+    return 1;
+  }
+
+  const serverUrl = resolveServerUrl(env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
+  const sendHeartbeat = async () => {
+    const res = await fetchImpl(`${serverUrl}/api/machines/heartbeat`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${authToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(machine),
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`HTTP ${res.status}\n${text}`);
+    }
+  };
+
+  if (hasFlag(args, "--daemon") || hasFlag(args, "--background")) {
+    const logPath = resolveDaemonLogPath(env);
+    const result = (deps.spawnDaemon ?? defaultSpawnDaemon)({
+      cmd: [process.execPath, import.meta.path, "connect", "--ws"],
+      cwd: process.cwd(),
+      env,
+      logPath,
+    });
+    output.write(`Connector daemon started${result.pid ? ` pid=${result.pid}` : ""}. Log: ${logPath}\n`);
+    return 0;
+  }
+
+  if (hasFlag(args, "--ws")) {
+    const sentMessages: string[] = [];
+    const heartbeatAbort = new AbortController();
+    try {
+      await sendHeartbeat();
+      output.write(`Connector websocket connected: ${machine.name} (${machine.machineId})\n`);
+      const heartbeatLoopPromise = (deps.runHeartbeatLoop ?? defaultRunHeartbeatLoop)({
+        intervalMs: resolveHeartbeatIntervalMs(env),
+        sendHeartbeat,
+        signal: heartbeatAbort.signal,
+      });
+      const wsTarget = await resolveConnectorWebSocketTarget({
+        serverUrl,
+        machineId: machine.machineId,
+        headers: { Authorization: `Bearer ${authToken}` },
+        fetchImpl,
+      });
+      const websocketPromise = (deps.connectWebSocket ?? defaultConnectWebSocket)(
+        wsTarget,
+        {
+          headers: { Authorization: `Bearer ${authToken}` },
+          sentMessages,
+          onMessage: (message) => handleConnectorRunMessage(
+            machine,
+            message,
+            (response) => sentMessages.push(response),
+            deps.executeCli ?? defaultExecuteCli
+          ),
+        }
+      );
+      await Promise.race([websocketPromise, heartbeatLoopPromise]);
+      heartbeatAbort.abort();
+      await Promise.allSettled([websocketPromise, heartbeatLoopPromise]);
+      return 0;
+    } catch (error) {
+      heartbeatAbort.abort();
+      output.write(
+        `[nolo] Connector websocket failed: ${
+          error instanceof Error ? error.message : String(error)
+        }\n`
+      );
+      return 1;
+    }
+  }
+
+  if (hasFlag(args, "--watch")) {
+    output.write(`Connecting machine heartbeat loop: ${machine.name} (${machine.platform}/${machine.arch})\n`);
+    try {
+      await (deps.runHeartbeatLoop ?? defaultRunHeartbeatLoop)({
+        intervalMs: resolveHeartbeatIntervalMs(env),
+        sendHeartbeat,
+      });
+      return 0;
+    } catch (error) {
+      output.write(
+        `[nolo] Machine heartbeat loop failed: ${
+          error instanceof Error ? error.message : String(error)
+        }\n`
+      );
+      return 1;
+    }
+  }
+
+  try {
+    await sendHeartbeat();
+  } catch (error) {
+    output.write(
+      `[nolo] Machine connect failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+
+  output.write(`Connected machine: ${machine.name} (${machine.platform}/${machine.arch})\n`);
+  return 0;
+}
+
+export async function runMachineStatusCommand(
+  _args: string[],
+  deps: MachineCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const authToken = resolveAuthToken(env);
+  if (!authToken) {
+    writeAuthMissing(output);
+    return 1;
+  }
+
+  const serverUrl = resolveServerUrl(env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  let res: Response;
+  try {
+    res = await fetchImpl(`${serverUrl}/api/machines`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+      },
+    });
+  } catch (error) {
+    output.write(
+      `[nolo] Machine status failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    output.write(`[nolo] Machine status failed: HTTP ${res.status}\n${text}\n`);
+    return 1;
+  }
+
+  const data = await res.json().catch(() => ({ machines: [] }));
+  const machines = Array.isArray(data?.machines) ? data.machines : [];
+  output.write(formatMachineStatus(machines));
+  return 0;
+}

package/package.json

@@ -1,22 +1,32 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
     "nolo": "index.ts"
   },
   "module": "index.ts",
+  "scripts": {
+    "build:publish": "bun build.ts"
+  },
   "files": [
     "index.ts",
+    "agentRuntimeCommands.ts",
     "authCommands.ts",
     "commandRegistry.ts",
+    "connectorWebSocketTarget.ts",
+    "defaultServer.ts",
+    "machineCommands.ts",
     "updateCommands.ts",
     "client/agentRun.ts",
+    "client/compactDialog.ts",
     "client/profileConfig.ts",
     "tui/readlineWorkspace.ts",
     "tui/session.ts",
-    "README.md"
+    "README.md",
+    "ai/**/*.ts",
+    "connector-experimental/**/*.ts"
   ],
   "publishConfig": {
     "access": "public"

package/tui/readlineWorkspace.ts

@@ -1,6 +1,8 @@
 import { createInterface } from "node:readline";
 import { stdin as defaultInput, stdout as defaultOutput } from "node:process";
 import { runAgentTurn, type RunAgentTurnResult } from "../client/agentRun";
+import { compactDialog, type CompactDialogResult } from "../client/compactDialog";
+import { runSelfUpdate } from "../updateCommands";
 import {
   createInitialTuiState,
   handleTuiInput,
@@ -10,12 +12,22 @@ import {
   type TuiState,
 } from "./session";
 
+export type SelfUpdater = (
+  output: NodeJS.WritableStream
+) => Promise<number>;
+
 type WorkspaceOptions = {
   scriptDir: string;
   env?: NodeJS.ProcessEnv;
   input?: NodeJS.ReadableStream;
   output?: NodeJS.WritableStream;
   agentRunner?: typeof runAgentTurn;
+  compactRunner?: (options: {
+    serverUrl: string;
+    authToken: string;
+    dialogId: string;
+  }) => Promise<CompactDialogResult>;
+  selfUpdater?: SelfUpdater;
 };
 
 async function runAgentChat(
@@ -43,6 +55,8 @@ export async function startTuiWorkspace(options: WorkspaceOptions) {
   let state = createInitialTuiState(options.env ?? process.env);
   const input = options.input ?? defaultInput;
   const output = options.output ?? defaultOutput;
+  const selfUpdater: SelfUpdater =
+    options.selfUpdater ?? ((target) => runSelfUpdate({ output: target }));
   const rl = createInterface({ input, output });
 
   output.write(renderWelcome(state));
@@ -62,6 +76,42 @@ export async function startTuiWorkspace(options: WorkspaceOptions) {
         break;
       }
 
+      if (result.action?.type === "compact") {
+        const runner = options.compactRunner ?? compactDialog;
+        const authToken =
+          options.env?.AUTH_TOKEN ?? options.env?.AUTH ?? options.env?.BENCHMARK_AUTH_TOKEN ?? "";
+        try {
+          const compactResult = await runner({
+            serverUrl: state.serverUrl,
+            authToken,
+            dialogId: result.action.dialogId,
+          });
+          state = {
+            ...state,
+            dialogId: compactResult.dialogId,
+            dialogLabel: compactResult.dialogId,
+          };
+        } catch (error: any) {
+          output.write(
+            `[nolo] Compact failed: ${error?.message ?? String(error)}\n`
+          );
+        }
+      }
+
+      if (result.action?.type === "self-update") {
+        try {
+          const exitCode = await selfUpdater(output);
+          if (exitCode === 0) {
+            output.write("Update finished. Restart nolo to use the new version.\n");
+          } else {
+            output.write("Update failed. Fix the npm error above, then run /update again or use nolo update.\n");
+          }
+        } catch (error) {
+          output.write(`${error instanceof Error ? error.message : String(error)}\n`);
+          output.write("Update failed. Fix the npm error above, then run /update again or use nolo update.\n");
+        }
+      }
+
       if (result.action?.type === "chat") {
         const runResult = await runAgentChat(
           options.scriptDir,

package/tui/session.ts

@@ -1,5 +1,7 @@
+import { DEFAULT_NOLO_SERVER_URL } from "../defaultServer";
+
 export const DEFAULT_TUI_AGENT_KEY = "agent-pub-01NOLOAPPBLD000000019KCKT0";
-export const DEFAULT_TUI_SERVER_URL = "http://127.0.0.1:38123";
+export const DEFAULT_TUI_SERVER_URL = DEFAULT_NOLO_SERVER_URL;
 
 const KNOWN_AGENTS: Array<{
   name: string;
@@ -51,6 +53,13 @@ export type TuiAction =
       agentKey: string;
       continueDialogId?: string;
     }
+  | {
+      type: "compact";
+      dialogId: string;
+    }
+  | {
+      type: "self-update";
+    }
   | {
       type: "exit";
     };
@@ -73,7 +82,10 @@ export function createInitialTuiState(env: EnvLike = process.env): TuiState {
     dialogId: env.NOLO_DIALOG_ID?.trim() || undefined,
     dialogLabel: env.NOLO_DIALOG?.trim() || "new",
     profileName: env.NOLO_PROFILE?.trim() || "local",
-    serverUrl: (env.NOLO_SERVER || env.BASE_URL || DEFAULT_TUI_SERVER_URL).replace(/\/+$/, ""),
+    serverUrl: (env.NOLO_SERVER || env.BASE_URL || DEFAULT_TUI_SERVER_URL).replace(
+      /\/+$/,
+      ""
+    ),
     cliVersion: env.NOLO_CLI_VERSION?.trim() || undefined,
     attachedDocs: [],
   };
@@ -117,6 +129,7 @@ export function renderTuiHelp() {
     "Commands:",
     "  /help                 Show this help",
     "  /new                  Start a fresh dialog",
+    "  /compact              Compact current dialog and fork a new one",
     "  /context              Show workspace context and next actions",
     "  /agent                Show the current agent",
     "  /agents               List built-in agent shortcuts",
@@ -127,6 +140,7 @@ export function renderTuiHelp() {
     "  /customize            Describe how you want to tune nolo",
     "  /login                Show login/profile hint",
     "  /profile              Show active profile",
+    "  /update               Update the global nolo install",
     "  /version              Show version/update hint",
     "  /exit                 Leave the workspace",
     "",
@@ -221,6 +235,24 @@ export function handleTuiInput(input: string, state: TuiState): TuiInputResult {
         },
         output: "Started a fresh dialog.",
       };
+    case "/compact":
+      if (argText) {
+        return {
+          nextState: state,
+          output: `Unknown command: ${trimmed}\n\n${renderTuiHelp()}`,
+        };
+      }
+      if (!state.dialogId) {
+        return {
+          nextState: state,
+          output: "Current dialog: new (nothing to compact yet)",
+        };
+      }
+      return {
+        nextState: state,
+        output: "Compacting current dialog...",
+        action: { type: "compact", dialogId: state.dialogId },
+      };
     case "/agent":
       return {
         nextState: state,
@@ -302,6 +334,12 @@ export function handleTuiInput(input: string, state: TuiState): TuiInputResult {
         nextState: state,
         output: `Profile: ${state.profileName}`,
       };
+    case "/update":
+      return {
+        nextState: state,
+        output: "Starting self-update...",
+        action: { type: "self-update" },
+      };
     case "/version":
       return {
         nextState: state,

package/updateCommands.ts

@@ -15,6 +15,13 @@ type DoctorInfo = {
   profileName: string;
 };
 
+type RunSelfUpdateOptions = {
+  output?: NodeJS.WritableStream;
+  spawn?: typeof Bun.spawn;
+};
+
+type SpawnOutputChunk = string | ArrayBuffer | ArrayBufferView;
+
 const CLI_DIR = dirname(fileURLToPath(import.meta.url));
 const PACKAGE_JSON_PATH = join(CLI_DIR, "package.json");
 
@@ -53,17 +60,75 @@ export function buildCliDoctorText(info: DoctorInfo) {
   ].join("\n");
 }
 
-export async function runSelfUpdate(output: NodeJS.WritableStream = process.stdout) {
+function isRunSelfUpdateOptions(
+  value: NodeJS.WritableStream | RunSelfUpdateOptions
+): value is RunSelfUpdateOptions {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    ("output" in value || "spawn" in value)
+  );
+}
+
+async function forwardSpawnOutput(
+  stream: AsyncIterable<SpawnOutputChunk> | undefined,
+  output: NodeJS.WritableStream
+) {
+  if (!stream) {
+    return;
+  }
+
+  for await (const chunk of stream) {
+    output.write(normalizeSpawnChunk(chunk));
+  }
+}
+
+function normalizeSpawnChunk(
+  chunk: SpawnOutputChunk
+): string | Uint8Array<ArrayBufferLike> {
+  if (typeof chunk === "string" || chunk instanceof Uint8Array) {
+    return chunk;
+  }
+
+  if (chunk instanceof ArrayBuffer) {
+    return new Uint8Array(chunk);
+  }
+
+  return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+}
+
+export async function runSelfUpdate(
+  outputOrOptions?: NodeJS.WritableStream | RunSelfUpdateOptions
+) {
+  const options =
+    outputOrOptions === undefined
+      ? {}
+      : isRunSelfUpdateOptions(outputOrOptions)
+        ? outputOrOptions
+        : { output: outputOrOptions };
+  const output = options.output ?? process.stdout;
+  const spawn = options.spawn ?? Bun.spawn;
   const command = buildSelfUpdateCommand();
   output.write(`Updating nolo with: ${command.join(" ")}\n`);
 
-  const proc = Bun.spawn({
+  const useCustomSink = options.output !== undefined;
+  const proc = spawn({
     cmd: command,
     stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
+    stdout: useCustomSink ? "pipe" : "inherit",
+    stderr: useCustomSink ? "pipe" : "inherit",
     env: process.env,
   });
 
-  return await proc.exited;
+  if (!useCustomSink) {
+    return await proc.exited;
+  }
+
+  const [exitCode] = await Promise.all([
+    proc.exited,
+    forwardSpawnOutput(proc.stdout, output),
+    forwardSpawnOutput(proc.stderr, output),
+  ]);
+
+  return exitCode;
 }