nolo-cli 0.1.8 → 0.1.10

package/client/compactDialog.ts

@@ -0,0 +1,222 @@
+// packages/cli/client/compactDialog.ts
+// HTTP-only compact helper for CLI TUI (no Redux store available).
+
+import { ulid } from "ulid";
+
+const DB_PATH = "/api/v1/db";
+
+/**
+ * Extract userId from a JWT-style auth token without verifying the signature.
+ * Mirrors the logic of `parseToken` in `auth/token.ts` without the crypto imports.
+ * @internal - exported for testing only
+ */
+export function parseTokenUserId(token: string): string | null {
+  try {
+    const parts = token.split(".");
+    if (parts.length < 2) return null;
+    const payloadBase64 = parts[1];
+    const payload = JSON.parse(
+      Buffer.from(payloadBase64, "base64").toString("utf8")
+    );
+    return typeof payload?.userId === "string" ? payload.userId : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract the custom ID (ULID) from a dialog key like `dialog-{userId}-{id}`.
+ * Mirrors `extractCustomId` from `core/prefix` without importing it.
+ */
+function extractCustomId(key: string): string {
+  const parts = key.split("-");
+  return parts.slice(2).join("-");
+}
+
+async function readDialogRecord(
+  fetchImpl: typeof fetch,
+  serverUrl: string,
+  authToken: string,
+  dialogKey: string
+): Promise<Record<string, unknown>> {
+  const res = await fetchImpl(`${serverUrl}${DB_PATH}/read/${dialogKey}`, {
+    headers: { Authorization: `Bearer ${authToken}` },
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to read dialog "${dialogKey}": HTTP ${res.status}`);
+  }
+  const data = await res.json();
+  return data as Record<string, unknown>;
+}
+
+/**
+ * Fields carried forward from the source dialog into the fork.
+ * Conversation summary/compression state is intentionally excluded so the new
+ * dialog starts clean: summary, summarizedBeforeId, proactiveSummary,
+ * proactiveSummaryBeforeId, compressionCount, summaryPending must NOT be
+ * inherited — they describe the old conversation, not the fork.
+ */
+const FORKED_CARRY_FIELDS = [
+  "cybots",
+  "type",
+  "title",
+  "spaceId",
+  "category",
+  "referenceKeys",
+  "triggerType",
+  "schedule",
+  "taskPrompt",
+  "executionMode",
+] as const;
+
+function buildForkedDialogRecord(
+  current: Record<string, unknown>,
+  userId: string
+): Record<string, unknown> & { dbKey: string; id: string } {
+  const newId = ulid();
+  const dbKey = `dialog-${userId}-${newId}`;
+  const now = new Date().toISOString();
+
+  // Explicitly pick only the allowed fields — never spread `current` wholesale.
+  const carried: Record<string, unknown> = {};
+  for (const field of FORKED_CARRY_FIELDS) {
+    if (current[field] !== undefined) {
+      carried[field] = current[field];
+    }
+  }
+
+  return {
+    ...carried,
+    id: newId,
+    dbKey,
+    inheritedFromDialogKey: current.dbKey,
+    inheritedFromDialogTitle: current.title,
+    createdAt: now,
+    updatedAt: now,
+    // reset per-dialog stats
+    inputTokens: 0,
+    outputTokens: 0,
+    totalCost: 0,
+  };
+}
+
+async function writeDialogRecord(
+  fetchImpl: typeof fetch,
+  serverUrl: string,
+  authToken: string,
+  record: Record<string, unknown> & { dbKey: string }
+): Promise<void> {
+  const res = await fetchImpl(`${serverUrl}${DB_PATH}/write/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${authToken}`,
+    },
+    body: JSON.stringify({ data: record, customKey: record.dbKey }),
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Failed to write forked dialog "${record.dbKey}": HTTP ${res.status}`
+    );
+  }
+}
+
+/**
+ * Best-effort: register the forked dialog in the space sidebar.
+ * Failure here is non-fatal since the dialog is already stored.
+ */
+async function addDialogToSpaceIfNeeded(
+  fetchImpl: typeof fetch,
+  serverUrl: string,
+  authToken: string,
+  record: Record<string, unknown> & { dbKey: string }
+): Promise<void> {
+  const rawSpaceId = record.spaceId;
+  if (!rawSpaceId || typeof rawSpaceId !== "string") return;
+
+  const normalizedSpaceId = rawSpaceId.startsWith("space-")
+    ? rawSpaceId.slice("space-".length)
+    : rawSpaceId;
+  const spaceKey = `space-${normalizedSpaceId}`;
+  const now = Date.now();
+
+  const contentEntry = {
+    title: typeof record.title === "string" ? record.title : record.id,
+    type: "dialog",
+    contentKey: record.dbKey,
+    pinned: false,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  try {
+    const res = await fetchImpl(`${serverUrl}${DB_PATH}/patch/${spaceKey}`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authToken}`,
+      },
+      body: JSON.stringify({ contents: { [record.dbKey]: contentEntry } }),
+    });
+    if (!res.ok) {
+      console.warn(
+        `[nolo] compact: addDialogToSpace failed for ${spaceKey}: HTTP ${res.status}`
+      );
+    }
+  } catch (error) {
+    console.warn(`[nolo] compact: addDialogToSpace error: ${error}`);
+  }
+}
+
+export type CompactDialogResult = {
+  dialogId: string;
+  dialogKey: string;
+  spaceId?: string;
+};
+
+/**
+ * Compact the current dialog by forking it:
+ * 1. Read the current dialog config from the server.
+ * 2. Build a new dialog record that inherits from the old one.
+ * 3. Write the new record to the server.
+ * 4. Register the new dialog in the space sidebar (best-effort).
+ *
+ * Returns the new dialog's ID so the TUI can switch to it.
+ */
+export async function compactDialog(options: {
+  serverUrl: string;
+  authToken: string;
+  dialogId: string;
+  fetchImpl?: typeof fetch;
+}): Promise<CompactDialogResult> {
+  const fetchImpl = options.fetchImpl ?? fetch;
+
+  const userId = parseTokenUserId(options.authToken);
+  if (!userId) {
+    throw new Error(
+      "[nolo] compact: cannot compact — invalid or missing auth token"
+    );
+  }
+
+  const dialogKey = `dialog-${userId}-${options.dialogId}`;
+  const current = await readDialogRecord(
+    fetchImpl,
+    options.serverUrl,
+    options.authToken,
+    dialogKey
+  );
+  const next = buildForkedDialogRecord(current, userId);
+  await writeDialogRecord(fetchImpl, options.serverUrl, options.authToken, next);
+  await addDialogToSpaceIfNeeded(
+    fetchImpl,
+    options.serverUrl,
+    options.authToken,
+    next
+  );
+
+  return {
+    dialogId: extractCustomId(next.dbKey),
+    dialogKey: next.dbKey,
+    spaceId: typeof next.spaceId === "string" ? next.spaceId : undefined,
+  };
+}

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

@@ -1,5 +1,5 @@
-import type { MachineHeartbeat } from "connector-experimental/protocol";
-import { detectMachineInfo } from "connector-experimental/machineInfo";
+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";
@@ -7,12 +7,12 @@ import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import {
   type HeartbeatLoopOptions,
   runHeartbeatLoop as defaultRunHeartbeatLoop,
-} from "connector-experimental/heartbeatLoop";
+} from "./connector-experimental/heartbeatLoop";
 import {
   assertMachineRunAllowed,
   buildMachinePermissionPromptBlock,
   resolveMachineRunPermissionPolicy,
-} from "../ai/agent/machineRunPermissions";
+} from "./ai/agent/machineRunPermissions";
 import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
 
 type EnvLike = Record<string, string | undefined>;

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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",
@@ -17,10 +20,13 @@
     "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"
@@ -28,11 +34,21 @@
   "devDependencies": {
     "bun-types": "latest"
   },
-  "dependencies": {
-    "ai": "workspace:*",
-    "connector-experimental": "workspace:*"
-  },
   "peerDependencies": {
     "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@reduxjs/toolkit": "^2.5.0",
+    "iztro": "^2.5.8",
+    "ulid": "^2.3.0",
+    "pino": "^9.9.0",
+    "react": "^19.2.1",
+    "i18next": "^23.11.5",
+    "zod": "^3.25.20",
+    "react-hook-form": "^7.51.5",
+    "@hookform/resolvers": "^3.3.2",
+    "react-i18next": "^14.1.2",
+    "react-hot-toast": "^2.4.1",
+    "react-native-sse": "^1.2.1"
   }
 }