nolo-cli 0.1.6 → 0.1.8

package/index.ts

@@ -1,105 +1,159 @@
 #!/usr/bin/env bun
-
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { renderHelpText, resolveCommand } from "./commandRegistry";
-import { runLoginCommand, runLogoutCommand, runWhoamiCommand } from "./authCommands";
-import { buildEnvFromProfile, loadProfileConfig } from "./client/profileConfig";
-import { startTuiWorkspace } from "./tui/readlineWorkspace";
-import {
-  buildCliDoctorText,
-  buildCliVersionText,
-  readPackageInfo,
-  runSelfUpdate,
-} from "./updateCommands";
-
-const CLI_DIR = dirname(fileURLToPath(import.meta.url));
-const ROOT_DIR = join(CLI_DIR, "..", "..");
-const SCRIPT_DIR = join(ROOT_DIR, "scripts");
-const packageInfo = readPackageInfo();
-
-async function runScript(script: string, forwardedArgs: string[]) {
-  const scriptPath = join(SCRIPT_DIR, script);
-  const proc = Bun.spawn({
-    cmd: [process.execPath, scriptPath, ...forwardedArgs],
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-    env: process.env,
-  });
-  const exitCode = await proc.exited;
-  process.exit(exitCode);
-}
-
-const args = process.argv.slice(2);
-const profileEnv = buildEnvFromProfile(loadProfileConfig());
-const runtimeEnv = {
-  ...profileEnv,
-  ...process.env,
-  NOLO_CLI_VERSION: packageInfo.version,
-};
-
-if (args.length === 0) {
-  if (process.stdin.isTTY) {
-    await startTuiWorkspace({ scriptDir: SCRIPT_DIR, env: runtimeEnv });
-  } else {
-    console.log(renderHelpText());
-  }
-  process.exit(0);
-}
-
-if (args.length === 1 && (args[0] === "tui" || args[0] === "chat")) {
-  await startTuiWorkspace({ scriptDir: SCRIPT_DIR, env: runtimeEnv });
-  process.exit(0);
-}
-
-if (args[0] === "login") {
-  process.exit(await runLoginCommand(args.slice(1)));
-}
-
-if (args[0] === "whoami") {
-  process.exit(runWhoamiCommand());
-}
-
-if (args[0] === "logout") {
-  process.exit(runLogoutCommand());
-}
-
-if (args[0] === "--version" || args[0] === "-v" || args[0] === "version") {
-  console.log(buildCliVersionText(packageInfo));
-  process.exit(0);
-}
-
-if (args[0] === "doctor") {
-  console.log(
-    buildCliDoctorText({
-      packageName: packageInfo.name,
-      version: packageInfo.version,
-      entrypoint: fileURLToPath(import.meta.url),
-      serverUrl: runtimeEnv.NOLO_SERVER || runtimeEnv.BASE_URL || "http://127.0.0.1:38123",
-      profileName: runtimeEnv.NOLO_PROFILE || "local",
-    })
-  );
-  process.exit(0);
-}
-
-if (args[0] === "update") {
-  process.exit(await runSelfUpdate());
-}
-
-if (args[0] === "--help" || args[0] === "-h") {
-  console.log(renderHelpText());
-  process.exit(0);
-}
-
-const command = resolveCommand(args);
-if (!command) {
-  console.error(`Unknown command: ${args.join(" ")}`);
-  console.error("");
-  console.log(renderHelpText());
-  process.exit(1);
-}
-
-const forwardedArgs = args.slice(command.path.length);
-await runScript(command.script, forwardedArgs);
+
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { renderHelpText, resolveCommand } from "./commandRegistry";
+import { runLoginCommand, runLogoutCommand, runWhoamiCommand } from "./authCommands";
+import {
+  runAgentBindCurrentCommand,
+  runAgentRuntimeDoctorCommand,
+  runAgentSmokeCurrentCommand,
+} from "./agentRuntimeCommands";
+import { buildEnvFromProfile, loadProfileConfig } from "./client/profileConfig";
+import {
+  runMachineConnectCommand,
+  runMachineStatusCommand,
+} from "./machineCommands";
+import { startTuiWorkspace } from "./tui/readlineWorkspace";
+import {
+  buildCliDoctorText,
+  buildCliVersionText,
+  readPackageInfo,
+  runSelfUpdate,
+} from "./updateCommands";
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+
+const CLI_DIR = dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = join(CLI_DIR, "..", "..");
+const SCRIPT_DIR = join(ROOT_DIR, "scripts");
+const packageInfo = readPackageInfo();
+
+async function runScript(script: string, forwardedArgs: string[], env: NodeJS.ProcessEnv) {
+  const scriptPath = join(SCRIPT_DIR, script);
+  const proc = Bun.spawn({
+    cmd: [process.execPath, scriptPath, ...forwardedArgs],
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env,
+  });
+  const exitCode = await proc.exited;
+  process.exit(exitCode);
+}
+
+const args = process.argv.slice(2);
+const profileEnv = buildEnvFromProfile(loadProfileConfig());
+const runtimeEnv = {
+  ...profileEnv,
+  ...process.env,
+  NOLO_CLI_VERSION: packageInfo.version,
+};
+
+function readOption(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function buildDaemonEnv(args: string[]) {
+  const serverUrl = readOption(args, "--server-url") || readOption(args, "--server");
+  const apiKey = readOption(args, "--api-key") || readOption(args, "--token");
+  return {
+    ...runtimeEnv,
+    ...(serverUrl ? { NOLO_SERVER: serverUrl } : {}),
+    ...(apiKey ? { AUTH_TOKEN: apiKey } : {}),
+  };
+}
+
+function looksLikeDaemonShortcut(args: string[]) {
+  return args.includes("--server-url") || args.includes("--api-key");
+}
+
+if (args.length === 0) {
+  if (process.stdin.isTTY) {
+    await startTuiWorkspace({ scriptDir: SCRIPT_DIR, env: runtimeEnv });
+  } else {
+    console.log(renderHelpText());
+  }
+  process.exit(0);
+}
+
+if (args.length === 1 && (args[0] === "tui" || args[0] === "chat")) {
+  await startTuiWorkspace({ scriptDir: SCRIPT_DIR, env: runtimeEnv });
+  process.exit(0);
+}
+
+if (args[0] === "login") {
+  process.exit(await runLoginCommand(args.slice(1)));
+}
+
+if (args[0] === "whoami") {
+  process.exit(runWhoamiCommand());
+}
+
+if (args[0] === "logout") {
+  process.exit(runLogoutCommand());
+}
+
+if (args[0] === "connect") {
+  process.exit(await runMachineConnectCommand(args.slice(1), { env: runtimeEnv }));
+}
+
+if (args[0] === "daemon" || looksLikeDaemonShortcut(args)) {
+  const daemonArgs = args[0] === "daemon" ? args.slice(1) : args;
+  process.exit(await runMachineConnectCommand(["--ws"], { env: buildDaemonEnv(daemonArgs) }));
+}
+
+if (args[0] === "machine" && args[1] === "status") {
+  process.exit(await runMachineStatusCommand(args.slice(2), { env: runtimeEnv }));
+}
+
+if (args[0] === "agent" && args[1] === "bind-current") {
+  process.exit(await runAgentBindCurrentCommand(args.slice(2), { env: runtimeEnv }));
+}
+
+if (args[0] === "agent" && args[1] === "smoke-current") {
+  process.exit(await runAgentSmokeCurrentCommand(args.slice(2), { env: runtimeEnv }));
+}
+
+if (args[0] === "agent" && args[1] === "runtime-doctor") {
+  process.exit(await runAgentRuntimeDoctorCommand(args.slice(2), { env: runtimeEnv }));
+}
+
+if (args[0] === "--version" || args[0] === "-v" || args[0] === "version") {
+  console.log(buildCliVersionText(packageInfo));
+  process.exit(0);
+}
+
+if (args[0] === "doctor") {
+  console.log(
+    buildCliDoctorText({
+      packageName: packageInfo.name,
+      version: packageInfo.version,
+      entrypoint: fileURLToPath(import.meta.url),
+      serverUrl: runtimeEnv.NOLO_SERVER || runtimeEnv.BASE_URL || DEFAULT_NOLO_SERVER_URL,
+      profileName: runtimeEnv.NOLO_PROFILE || "local",
+    })
+  );
+  process.exit(0);
+}
+
+if (args[0] === "update") {
+  process.exit(await runSelfUpdate());
+}
+
+if (args[0] === "--help" || args[0] === "-h") {
+  console.log(renderHelpText());
+  process.exit(0);
+}
+
+const command = resolveCommand(args);
+if (!command) {
+  console.error(`Unknown command: ${args.join(" ")}`);
+  console.error("");
+  console.log(renderHelpText());
+  process.exit(1);
+}
+
+const forwardedArgs = args.slice(command.path.length);
+await runScript(command.script, forwardedArgs, runtimeEnv);

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,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -9,8 +9,12 @@
   "module": "index.ts",
   "files": [
     "index.ts",
+    "agentRuntimeCommands.ts",
     "authCommands.ts",
     "commandRegistry.ts",
+    "connectorWebSocketTarget.ts",
+    "defaultServer.ts",
+    "machineCommands.ts",
     "updateCommands.ts",
     "client/agentRun.ts",
     "client/profileConfig.ts",
@@ -24,6 +28,10 @@
   "devDependencies": {
     "bun-types": "latest"
   },
+  "dependencies": {
+    "ai": "workspace:*",
+    "connector-experimental": "workspace:*"
+  },
   "peerDependencies": {
     "typescript": "^5.0.0"
   }