nolo-cli 0.1.6 → 0.1.8

package/README.md

@@ -37,10 +37,16 @@ nolo
 nolo doctor
 nolo --version
 
-# update later, from inside nolo itself
+# update later from your shell
 nolo update
 ```
 
+Inside the TUI, run:
+
+```text
+/update
+```
+
 The npm package expects Bun to be available because the executable is a Bun
 TypeScript script. For agent calls outside this repository, provide a token:
 
@@ -58,19 +64,81 @@ nolo
 
 Local repo development can still use the script bridge without `AUTH_TOKEN`.
 
+Inside the TUI, `/update` is the shortcut for the same global `nolo update`
+command.
+
 ```bash
 nolo --help
 nolo doctor
 nolo update
 nolo
 nolo chat
+nolo connect
+nolo connect --watch
+nolo connect --daemon
+nolo daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx
+nolo machine status
 nolo run "summarize my latest agent dialogs"
 nolo doc create --title "Trip Notes" --body "hello"
 nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs"
 nolo agent list --json
+nolo agent bind-current agent-user-1-agent-1
+nolo agent runtime-doctor agent-user-1-agent-1
+nolo agent smoke-current agent-user-1-agent-1 --msg "ping"
 nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"
 ```
 
+Experimental machine connector commands:
+
+```bash
+nolo connect          # send one machine heartbeat
+nolo connect --watch  # keep this terminal process online with periodic heartbeats
+nolo connect --ws     # keep a live connector websocket for bound agent runs
+nolo connect --daemon # start connect --ws silently in the background
+nolo daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx
+nolo machine status   # list machines registered to the current profile
+```
+
+These commands only register machine presence and runtime capabilities today.
+They do not expose shell, file-write, or raw local LLM endpoints.
+
+Run a Slock-style connector command:
+
+```bash
+nolo daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx
+```
+
+Future published package shape:
+
+```bash
+npx @nolo/daemon@latest --server-url https://api.nolo.chat --api-key sk_machine_xxx
+```
+
+The daemon registers this computer, reports local CLI capabilities, keeps a live
+websocket open, and executes bound CLI agents on this computer. Agents bind to a
+machine, not to a workspace or project folder.
+
+Bind an agent to the current machine:
+
+```bash
+nolo agent bind-current <agentKey>
+```
+
+The agent keeps its own CLI settings. The binding only records which connected
+machine must be online when that agent runs.
+
+Run a one-command connector smoke test:
+
+```bash
+nolo agent runtime-doctor <agentKey>
+nolo agent smoke-current <agentKey> --msg "ping"
+```
+
+`runtime-doctor` checks whether the agent is a CLI agent and whether the current
+machine has the required CLI capability. `smoke-current` heartbeats the current
+machine, binds the agent to it, opens a temporary connector websocket, calls
+`/api/agent/run`, and prints the returned dialog id/content.
+
 ## Product Shape
 
 The preferred command model is Agent-first:
@@ -86,13 +154,16 @@ nolo doc list --agent <agent>
 nolo table query <table> --agent <agent>
 ```
 
-Inside the future TUI, the same actions should be available as slash commands:
+Inside the current TUI, examples of supported slash commands include:
+`/agent`, `/agents`, `/switch`, `/context` (alias `/ctx`), `/dialog`, `/doc`,
+`/help`, `/new`, `/customize`, `/login`, `/profile`, `/version`, `/quit`
+(alias `/exit`), and `/update` (which maps to `nolo update`).
+
+Future product-direction examples for the broader TUI command model:
 
 ```text
 /agent list
 /agent switch ops
-/agents
-/switch 2
 /dialog open latest
 /doc list
 /table query builtin-dialog-probe-runs

package/agentRuntimeCommands.ts

@@ -0,0 +1,464 @@
+import type { MachineHeartbeat } from "connector-experimental/protocol";
+import { detectMachineInfo } from "connector-experimental/machineInfo";
+import {
+  assertMachineRunAllowed,
+  buildMachinePermissionPromptBlock,
+  resolveMachineRunPermissionPolicy,
+} from "../ai/agent/machineRunPermissions";
+import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+
+type EnvLike = Record<string, string | undefined>;
+type OutputLike = { write(chunk: string): unknown };
+type SmokeWebSocketOptions = {
+  headers: Record<string, string>;
+  onMessage: (message: string) => void | Promise<void>;
+  onOpen: () => void | Promise<void>;
+  sentMessages: string[];
+};
+type LocalCliExecutor = (
+  provider: string,
+  prompt: string,
+  options: { model?: string; yolo?: boolean }
+) => Promise<{ text: string; raw?: string; elapsed?: number }>;
+
+type AgentRuntimeCommandDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  fetchImpl?: typeof fetch;
+  machineInfo?: () => MachineHeartbeat;
+  connectWebSocket?: (url: string, options: SmokeWebSocketOptions) => Promise<void>;
+  executeCli?: LocalCliExecutor;
+};
+
+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 parseUserIdFromAuthToken(token: string) {
+  const payload = token.trim().split(".")[0];
+  if (!payload) return "";
+  try {
+    const parsed = JSON.parse(Buffer.from(payload, "base64").toString("utf8"));
+    return typeof parsed?.userId === "string" ? parsed.userId : "";
+  } catch {
+    return "";
+  }
+}
+
+function readOption(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : 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");
+}
+
+function requiredCapabilityForAgent(agent: any) {
+  if (agent?.apiSource !== "cli") return "";
+  const cliProvider = String(agent?.cliProvider || "").trim();
+  const capabilityByProvider: Record<string, string> = {
+    codex: "codex-cli",
+    claude: "claude-code",
+    copilot: "copilot-cli",
+    gemini: "gemini-cli",
+    kimi: "kimi-cli",
+  };
+  return capabilityByProvider[cliProvider] ?? "";
+}
+
+function assertSmokeCompatible(agent: any, machine: MachineHeartbeat) {
+  if (agent?.apiSource !== "cli") {
+    throw new Error(`Agent ${agent?.name ?? agent?.dbKey ?? "unknown"} is not a CLI agent.`);
+  }
+  const requiredCapability = requiredCapabilityForAgent(agent);
+  if (!requiredCapability) {
+    throw new Error(`Agent ${agent?.name ?? agent?.dbKey ?? "unknown"} has unsupported cliProvider: ${agent?.cliProvider ?? "missing"}.`);
+  }
+  if (!machine.capabilities.includes(requiredCapability)) {
+    const currentCapabilities = machine.capabilities.length
+      ? machine.capabilities.join(", ")
+      : "none";
+    throw new Error(
+      `Agent ${agent?.name ?? agent?.dbKey ?? "unknown"} requires ${requiredCapability}; current machine capabilities: ${currentCapabilities}.`
+    );
+  }
+}
+
+async function defaultConnectWebSocket(url: string, options: SmokeWebSocketOptions) {
+  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);
+    ws.addEventListener("open", () => {
+      Promise.resolve(options.onOpen())
+        .then(() => ws.close())
+        .catch((error) => {
+          ws.close();
+          reject(error);
+        });
+    }, { once: true });
+    ws.addEventListener("error", () => reject(new Error("connector websocket failed")));
+    ws.addEventListener("close", () => resolve(), { 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(reject);
+    });
+  });
+}
+
+async function handleSmokeConnectorMessage(
+  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),
+    }));
+  }
+}
+
+async function readAgentRecord(args: {
+  agentKey: string;
+  authToken: string;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+}) {
+  const res = await args.fetchImpl(
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.agentKey)}`,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${args.authToken}` },
+    }
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`read failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return data?.data ?? data;
+}
+
+async function writeAgentRecord(args: {
+  agentKey: string;
+  authToken: string;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  userId: string;
+  record: Record<string, any>;
+}) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/v1/db/write/`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      customKey: args.agentKey,
+      userId: args.userId,
+      data: {
+        ...args.record,
+        dbKey: args.agentKey,
+      },
+    }),
+  });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`write failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+}
+
+async function heartbeatCurrentMachine(args: {
+  authToken: string;
+  fetchImpl: typeof fetch;
+  machine: MachineHeartbeat;
+  serverUrl: string;
+}) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/machines/heartbeat`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(args.machine),
+  });
+  const text = await res.text().catch(() => "");
+  if (!res.ok) {
+    throw new Error(`heartbeat failed: HTTP ${res.status} ${text}`);
+  }
+}
+
+export async function runAgentBindCurrentCommand(
+  args: string[],
+  deps: AgentRuntimeCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const agentKey = args[0]?.trim();
+  if (!agentKey || agentKey === "--help" || agentKey === "-h") {
+    output.write("Usage: nolo agent bind-current <agentKey>\n");
+    return agentKey ? 0 : 1;
+  }
+
+  const authToken = resolveAuthToken(env);
+  if (!authToken) {
+    output.write("[nolo] agent bind-current requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent bind-current could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const serverUrl = resolveServerUrl(env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
+
+  try {
+    await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
+    const existing = await readAgentRecord({ agentKey, authToken, fetchImpl, serverUrl });
+    const updated = {
+      ...existing,
+      runtimeBinding: {
+        ...(existing?.runtimeBinding && typeof existing.runtimeBinding === "object"
+          ? existing.runtimeBinding
+          : {}),
+        machineId: machine.machineId,
+      },
+      updatedAt: Date.now(),
+    };
+    await writeAgentRecord({
+      agentKey,
+      authToken,
+      fetchImpl,
+      serverUrl,
+      userId,
+      record: updated,
+    });
+  } catch (error) {
+    output.write(
+      `[nolo] agent bind-current failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+
+  output.write(`Bound agent ${agentKey} to this machine: ${machine.name} (${machine.machineId})\n`);
+  return 0;
+}
+
+export async function runAgentSmokeCurrentCommand(
+  args: string[],
+  deps: AgentRuntimeCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const agentKey = args[0]?.trim();
+  if (!agentKey || agentKey === "--help" || agentKey === "-h") {
+    output.write("Usage: nolo agent smoke-current <agentKey> --msg \"hello\"\n");
+    return agentKey ? 0 : 1;
+  }
+
+  const authToken = resolveAuthToken(env);
+  if (!authToken) {
+    output.write("[nolo] agent smoke-current requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent smoke-current could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const userInput = readOption(args, "--msg") ?? "Smoke test from nolo connector.";
+  const serverUrl = resolveServerUrl(env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
+  const sentMessages: string[] = [];
+
+  try {
+    await heartbeatCurrentMachine({ authToken, fetchImpl, machine, serverUrl });
+    const existing = await readAgentRecord({ agentKey, authToken, fetchImpl, serverUrl });
+    assertSmokeCompatible(existing, machine);
+    await writeAgentRecord({
+      agentKey,
+      authToken,
+      fetchImpl,
+      serverUrl,
+      userId,
+      record: {
+        ...existing,
+        runtimeBinding: {
+          ...(existing?.runtimeBinding && typeof existing.runtimeBinding === "object"
+            ? existing.runtimeBinding
+            : {}),
+          machineId: machine.machineId,
+        },
+        updatedAt: Date.now(),
+      },
+    });
+
+    let runResponse: any = null;
+    const wsTarget = await resolveConnectorWebSocketTarget({
+      serverUrl,
+      machineId: machine.machineId,
+      headers: { Authorization: `Bearer ${authToken}` },
+      fetchImpl,
+    });
+    await (deps.connectWebSocket ?? defaultConnectWebSocket)(
+      wsTarget,
+      {
+        headers: { Authorization: `Bearer ${authToken}` },
+        sentMessages,
+        onMessage: (message) => handleSmokeConnectorMessage(
+          message,
+          (response) => sentMessages.push(response),
+          deps.executeCli ?? defaultExecuteCli
+        ),
+        onOpen: async () => {
+          const res = await fetchImpl(`${serverUrl}/api/agent/run`, {
+            method: "POST",
+            headers: {
+              Authorization: `Bearer ${authToken}`,
+              "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+              agentKey,
+              userInput,
+              stream: false,
+            }),
+          });
+          runResponse = await res.json().catch(() => ({}));
+          if (!res.ok) {
+            throw new Error(`agent run failed: HTTP ${res.status} ${JSON.stringify(runResponse)}`);
+          }
+        },
+      }
+    );
+    output.write(`Smoke OK: ${runResponse?.dialogId ?? "no-dialog"}\n`);
+    if (runResponse?.content) output.write(`${runResponse.content}\n`);
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent smoke-current failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}
+
+export async function runAgentRuntimeDoctorCommand(
+  args: string[],
+  deps: AgentRuntimeCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const agentKey = args[0]?.trim();
+  if (!agentKey || agentKey === "--help" || agentKey === "-h") {
+    output.write("Usage: nolo agent runtime-doctor <agentKey>\n");
+    return agentKey ? 0 : 1;
+  }
+
+  const authToken = resolveAuthToken(env);
+  if (!authToken) {
+    output.write("[nolo] agent runtime-doctor requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const serverUrl = resolveServerUrl(env);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const machine = (deps.machineInfo ?? detectLaunchableMachineInfo)();
+
+  try {
+    const agent = await readAgentRecord({ agentKey, authToken, fetchImpl, serverUrl });
+    const requiredCapability = requiredCapabilityForAgent(agent);
+    const isBoundToCurrent = agent?.runtimeBinding?.machineId === machine.machineId;
+    const hasCapability = requiredCapability
+      ? machine.capabilities.includes(requiredCapability)
+      : false;
+    output.write(`Agent runtime doctor: ${agent?.name ?? agentKey}\n`);
+    output.write(`Agent key: ${agentKey}\n`);
+    output.write(`API source: ${agent?.apiSource ?? "unknown"}\n`);
+    output.write(`CLI provider: ${agent?.cliProvider ?? "none"}\n`);
+    output.write(`Required capability: ${requiredCapability || "none"}\n`);
+    output.write(`Current machine: ${machine.name} (${machine.machineId})\n`);
+    output.write(`Current machine capabilities: ${machine.capabilities.length ? machine.capabilities.join(", ") : "none"}\n`);
+    output.write(`Current machine binding: ${isBoundToCurrent ? "yes" : "no"}\n`);
+    output.write(`Current machine has required capability: ${hasCapability ? "yes" : "no"}\n`);
+
+    if (agent?.apiSource !== "cli") return 1;
+    if (!requiredCapability || !hasCapability) return 1;
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent runtime-doctor failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}