nolo-cli 0.1.26 → 0.1.29

package/machineDaemonCommands.ts

@@ -0,0 +1,29 @@
+import {
+  checkConnectorWorkspaceLinks,
+  runConnectorDaemon,
+  type ConnectorDaemonDeps,
+} from "./connector-experimental/daemonLauncher";
+import type { OutputLike } from "./cliIoTypes";
+
+type EnvLike = Record<string, string | undefined>;
+
+export type MachineDaemonCommandDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  cliEntrypointPath?: string;
+  validateWorkspaceLinks?: (cwd: string) => string[] | Promise<string[]>;
+  spawnDaemon?: (args: {
+    cmd: string[];
+    cwd: string;
+    env: EnvLike;
+    logPath: string;
+  }) => { pid?: number };
+};
+
+export async function runMachineDaemonCommand(
+  deps: MachineDaemonCommandDeps = {}
+) {
+  return runConnectorDaemon(deps as ConnectorDaemonDeps);
+}
+
+export { checkConnectorWorkspaceLinks };

package/machineHeartbeatCommands.ts

@@ -0,0 +1,29 @@
+import type { MachineHeartbeat } from "./connector-experimental/protocol";
+import type { OutputLike } from "./cliIoTypes";
+
+export type MachineHeartbeatConnectDeps = {
+  output?: OutputLike;
+  machine: MachineHeartbeat;
+  sendHeartbeat: () => Promise<void>;
+};
+
+export async function runMachineHeartbeatConnectCommand(
+  deps: MachineHeartbeatConnectDeps
+) {
+  const output = deps.output ?? process.stdout;
+  const machine = deps.machine;
+
+  try {
+    await deps.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;
+}

package/machineStatusCommands.ts

@@ -0,0 +1,95 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import type { OutputLike } from "./cliIoTypes";
+
+type EnvLike = Record<string, string | undefined>;
+
+export type MachineSummary = {
+  machineId: string;
+  name: string;
+  platform: string;
+  arch: string;
+  connectorVersion: string | null;
+  capabilities: string[];
+  connectorStatus?: "connected" | "disconnected";
+  status: "online" | "offline";
+  lastSeenAt: number;
+};
+
+export type MachineStatusCommandDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  fetchImpl?: typeof fetch;
+};
+
+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"
+  );
+}
+
+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 runMachineStatusCommand(
+  _args: string[],
+  deps: MachineStatusCommandDeps = {}
+) {
+  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/machineWatchCommands.ts

@@ -0,0 +1,41 @@
+import type { MachineHeartbeat } from "./connector-experimental/protocol";
+import type { HeartbeatLoopOptions } from "./connector-experimental/heartbeatLoop";
+import type { OutputLike } from "./cliIoTypes";
+
+type EnvLike = Record<string, string | undefined>;
+
+function resolveHeartbeatIntervalMs(env: EnvLike) {
+  const raw = Number(env.NOLO_CONNECT_HEARTBEAT_MS ?? "");
+  return Number.isFinite(raw) && raw > 0 ? raw : 30_000;
+}
+
+export type MachineWatchCommandDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  machine: MachineHeartbeat;
+  sendHeartbeat: () => Promise<void>;
+  runHeartbeatLoop: (options: HeartbeatLoopOptions) => Promise<void>;
+};
+
+export async function runMachineWatchCommand(
+  deps: MachineWatchCommandDeps
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const machine = deps.machine;
+  output.write(`Connecting machine heartbeat loop: ${machine.name} (${machine.platform}/${machine.arch})\n`);
+  try {
+    await deps.runHeartbeatLoop({
+      intervalMs: resolveHeartbeatIntervalMs(env),
+      sendHeartbeat: deps.sendHeartbeat,
+    });
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] Machine heartbeat loop failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}

package/machineWsPromptMaterialization.ts

@@ -0,0 +1,89 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+type EnvLike = Record<string, string | undefined>;
+type RuntimePromptPage = {
+  dbKey?: string;
+  promptHash?: string;
+  contentBytes?: number;
+} | null | undefined;
+
+const CLOUD_PROMPT_PAGE_READ_COMMAND = "bun packages/cli/index.ts doc read";
+
+function byteLength(value: string) {
+  return Buffer.byteLength(value, "utf8");
+}
+
+function shortHash(value: string) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+
+function resolvePromptInlineMaxBytes(env: EnvLike) {
+  const raw = Number(env.NOLO_CONNECTOR_PROMPT_INLINE_MAX_BYTES);
+  return Number.isFinite(raw) && raw >= 1024 ? raw : 32_000;
+}
+
+// Owns prompt ref materialization for large connector prompts without changing ws dispatch behavior.
+export function materializeLargeConnectorPrompt(args: {
+  prompt: string;
+  cwd: string;
+  env: EnvLike;
+  requestId: string;
+  runtimePromptPage?: RuntimePromptPage;
+}) {
+  const promptBytes = byteLength(args.prompt);
+  const promptHash = shortHash(args.prompt);
+  const maxInlineBytes = resolvePromptInlineMaxBytes(args.env);
+  if (promptBytes <= maxInlineBytes) {
+    return {
+      prompt: args.prompt,
+      promptBytes,
+      promptHash,
+      promptRef: null as string | null,
+    };
+  }
+
+  const promptDir = join(args.cwd, ".nolo", "agent-prompts");
+  mkdirSync(promptDir, { recursive: true });
+  const promptRef = join(promptDir, `${args.requestId}-${promptHash}.md`);
+  writeFileSync(promptRef, args.prompt, "utf8");
+
+  return {
+    prompt: [
+      "A large Nolo runtime prompt has been materialized outside this command argument.",
+      ...(args.runtimePromptPage?.dbKey
+        ? [
+            "Cloud prompt page is the shared audit/context source.",
+            `Cloud prompt page: ${args.runtimePromptPage.dbKey}`,
+            `Read cloud page: ${CLOUD_PROMPT_PAGE_READ_COMMAND} ${JSON.stringify(args.runtimePromptPage.dbKey)}`,
+            ...(args.runtimePromptPage.promptHash
+              ? [`Cloud prompt sha256 prefix: ${args.runtimePromptPage.promptHash}`]
+              : []),
+            "",
+          ]
+        : []),
+      "Local prompt file is the execution-machine fallback and should match the cloud page content at run start.",
+      `Prompt file: ${promptRef}`,
+      `Prompt bytes: ${promptBytes}`,
+      `Prompt sha256 prefix: ${promptHash}`,
+      "",
+      "Prefer the cloud prompt page for shared context when readable; use the local prompt file as fallback.",
+      "Local repository edits, diffs, test output, and commits are still authoritative for local execution facts.",
+      "If neither source is readable, stop and report PROMPT_REF_UNREADABLE with both references.",
+    ].join("\n"),
+    promptBytes,
+    promptHash,
+    promptRef,
+  };
+}
+
+export function readRuntimePromptPageMeta(parsed: any) {
+  const page = parsed?.payload?.meta?.runtimePromptPage;
+  if (!page || typeof page !== "object") return null;
+  return {
+    dbKey: typeof page.dbKey === "string" ? page.dbKey : undefined,
+    promptHash: typeof page.promptHash === "string" ? page.promptHash : undefined,
+    contentBytes: typeof page.contentBytes === "number" ? page.contentBytes : undefined,
+  };
+}