nolo-cli 0.1.10 → 0.1.11

package/client/compactDialog.ts

@@ -1,222 +0,0 @@
-// 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

@@ -1,73 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

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

package/connector-experimental/machineInfo.ts

@@ -1,46 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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;
-}