nolo-cli 0.1.7 → 0.1.9

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/index.ts

@@ -0,0 +1,5 @@
+export * from "./capabilities";
+export * from "./codexBinary";
+export * from "./heartbeatLoop";
+export * from "./machineInfo";
+export * from "./protocol";

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/connectorWebSocketTarget.ts

@@ -0,0 +1,29 @@
+export async function resolveConnectorWebSocketTarget(input: {
+  serverUrl: string;
+  machineId: string;
+  headers: Record<string, string>;
+  fetchImpl?: typeof fetch;
+}) {
+  const directWsUrl = new URL(input.serverUrl);
+  directWsUrl.protocol = directWsUrl.protocol === "https:" ? "wss:" : "ws:";
+  directWsUrl.pathname = "/api/connector/ws";
+  directWsUrl.search = "";
+  directWsUrl.searchParams.set("machineId", input.machineId);
+
+  const probeUrl = new URL(input.serverUrl);
+  probeUrl.pathname = "/api/connector/ws";
+  probeUrl.search = directWsUrl.search;
+
+  const response = await (input.fetchImpl ?? fetch)(probeUrl, {
+    headers: input.headers,
+  }).catch(() => null);
+
+  if (!response || !response.ok) {
+    return directWsUrl.toString();
+  }
+
+  const json = await response.json().catch(() => null);
+  return typeof json?.wsUrl === "string" && json.wsUrl
+    ? json.wsUrl
+    : directWsUrl.toString();
+}

package/defaultServer.ts

@@ -0,0 +1 @@
+export const DEFAULT_NOLO_SERVER_URL = "https://nolo.chat";

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);