nolo-cli 0.1.30 → 0.1.32

package/cli/client/profileConfig.ts

@@ -0,0 +1,101 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+
+export type NoloProfile = {
+  serverUrl: string;
+  authToken: string;
+  agentKey?: string;
+  agentName?: string;
+};
+
+export type NoloProfileConfig = {
+  currentProfile: string;
+  profiles: Record<string, NoloProfile>;
+};
+
+export function normalizeProfileServerUrl(serverUrl: string) {
+  const normalized = serverUrl.trim().replace(/\/+$/, "");
+  if (!normalized) return normalized;
+  try {
+    const url = new URL(normalized);
+    if (url.protocol === "http:" && /\.?nolo\.chat$/i.test(url.hostname)) {
+      url.protocol = "https:";
+      return url.toString().replace(/\/+$/, "");
+    }
+  } catch {
+    return normalized;
+  }
+  return normalized;
+}
+
+export function getDefaultProfileConfigPath() {
+  return join(homedir(), ".nolo", "config.json");
+}
+
+export function loadProfileConfig(path = getDefaultProfileConfigPath()): NoloProfileConfig | null {
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf8");
+  const parsed = JSON.parse(raw) as NoloProfileConfig;
+  if (!parsed.currentProfile || !parsed.profiles?.[parsed.currentProfile]) return null;
+  for (const profile of Object.values(parsed.profiles)) {
+    if (!profile?.serverUrl) continue;
+    profile.serverUrl = normalizeProfileServerUrl(profile.serverUrl);
+  }
+  return parsed;
+}
+
+export function saveDefaultProfile(
+  path: string,
+  profile: NoloProfile
+): NoloProfileConfig {
+  const config: NoloProfileConfig = {
+    currentProfile: "default",
+    profiles: {
+      default: profile,
+    },
+  };
+  config.profiles.default.serverUrl = normalizeProfileServerUrl(
+    config.profiles.default.serverUrl
+  );
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  return config;
+}
+
+export function buildEnvFromProfile(config: NoloProfileConfig | null) {
+  if (!config) return {};
+  const profile = config.profiles[config.currentProfile];
+  if (!profile) return {};
+  return {
+    NOLO_PROFILE: config.currentProfile,
+    NOLO_SERVER: profile.serverUrl,
+    AUTH_TOKEN: profile.authToken,
+    ...(profile.agentKey ? { NOLO_AGENT: profile.agentKey } : {}),
+    ...(profile.agentName ? { NOLO_AGENT_NAME: profile.agentName } : {}),
+  };
+}
+
+export function buildCliRuntimeEnv(
+  processEnv: NodeJS.ProcessEnv,
+  config: NoloProfileConfig | null
+) {
+  const profileEnv = buildEnvFromProfile(config);
+  const explicitServerUrl =
+    processEnv.NOLO_SERVER || processEnv.NOLO_SERVER_URL || processEnv.BASE_URL;
+  return {
+    ...processEnv,
+    ...profileEnv,
+    ...(explicitServerUrl
+      ? {
+          NOLO_SERVER: explicitServerUrl,
+          BASE_URL: explicitServerUrl,
+        }
+      : {}),
+  };
+}
+
+export function getCurrentProfile(config: NoloProfileConfig | null) {
+  if (!config) return null;
+  return config.profiles[config.currentProfile] ?? null;
+}

package/cli/client/streamingOutput.ts

@@ -0,0 +1,36 @@
+import type { OutputLike } from "../cliIoTypes";
+
+export function splitStreamingText(content: string): string[] {
+  const Segmenter = Intl.Segmenter;
+  if (typeof Segmenter === "function") {
+    const segmenter = new Segmenter(undefined, { granularity: "grapheme" });
+    return Array.from(segmenter.segment(content), (part) => part.segment);
+  }
+  return Array.from(content);
+}
+
+export function createStreamingTextWriter({
+  write,
+  batchSize = 3,
+}: {
+  write: OutputLike["write"];
+  batchSize?: number;
+}) {
+  const queue: string[] = [];
+  const safeBatchSize = Math.max(1, batchSize);
+
+  const flushNext = () => {
+    if (!queue.length) return;
+    write(queue.splice(0, safeBatchSize).join(""));
+  };
+
+  return {
+    push(content: string) {
+      queue.push(...splitStreamingText(content));
+      flushNext();
+    },
+    flushAll() {
+      while (queue.length) flushNext();
+    },
+  };
+}

package/cli/client/taskRunPrompt.ts

@@ -0,0 +1,10 @@
+import {
+  prependTaskRunPromptForRuntime,
+  type TaskRunPromptContext,
+} from "../taskRunPromptShared";
+
+export type { TaskRunPromptContext };
+
+export function prependTaskRunPrompt(message: string, context?: TaskRunPromptContext): string {
+  return prependTaskRunPromptForRuntime(message, context, "cli");
+}

package/cli/client/taskWorktree.ts

@@ -0,0 +1,8 @@
+export {
+  ensureWorkspacePackageLinks,
+  formatPreparedGitTaskWorkspace as formatPreparedTaskWorktree,
+  prepareGitTaskWorkspace as prepareTaskWorktree,
+} from "../../agent-runtime/taskWorkspace";
+export type {
+  PreparedGitTaskWorkspace as PreparedTaskWorktree,
+} from "../../agent-runtime/taskWorkspace";

package/cli/client/workspaceSession.ts

@@ -0,0 +1,11 @@
+export {
+  activateWorkspaceSession,
+  createWorkspaceSession,
+  formatWorkspaceSessionActivation,
+} from "../../agent-runtime/workspaceSession";
+export type {
+  PrepareTaskWorkspace,
+  PreparedTaskWorkspace,
+  WorkspaceSession,
+  WorkspaceSessionMode,
+} from "../../agent-runtime/workspaceSession";

package/cli/commandRegistry.ts

@@ -0,0 +1,96 @@
+export type { CliPackageInfo, CliRuntimeContext, CommandEntry } from "./cliCommandTypes";
+export {
+  createCliRuntimeContext,
+  looksLikeDaemonShortcut,
+  runResolvedCommand,
+} from "./cliCommandDispatch";
+import type { CommandEntry } from "./cliCommandTypes";
+import { getInternalCommandEntries } from "./internalCommandEntries";
+import { getScriptCommandEntries } from "./scriptCommandEntries";
+
+export const COMMANDS: CommandEntry[] = [
+  ...getInternalCommandEntries(renderHelpText),
+  ...getScriptCommandEntries(),
+];
+
+export const GROUP_ORDER = [
+  "chat",
+  "doc",
+  "skill-doc",
+  "skill",
+  "agent",
+  "doctor",
+  "dialog",
+  "space",
+  "table",
+  "task-run",
+  "llama",
+  "model-runtime",
+  "dev",
+] as const;
+
+export function renderHelpText() {
+  const lines = [
+    "nolo — Agent-first terminal workspace",
+    "",
+    "Usage:",
+    "  nolo",
+    "  nolo <command> [subcommand] [...args]",
+    "  nolo doctor",
+    "  nolo update",
+    "",
+    "Examples:",
+    "  nolo",
+    "  nolo chat",
+    "  nolo login",
+    "  nolo login --no-browser",
+    "  nolo login --token <auth-token>",
+    "  nolo whoami",
+    "  nolo connect",
+    "  nolo connect --watch",
+    "  nolo connect --ws",
+    "  nolo connect --ws --server-url https://api.nolo.chat --api-key sk_machine_xxx",
+    "  nolo connect --daemon --server-url https://api.nolo.chat --api-key sk_machine_xxx",
+    "  nolo machine status",
+    "  nolo doctor",
+    "  nolo doctor runtime",
+    "  nolo update",
+    '  nolo doc create --title "Trip Notes" --body "hello" --space 01SPACEID --dry-run',
+    '  nolo skill-doc create --title "Agent Query Skill" --description "Inspect recent agent dialogs" --space 01SPACEID',
+    "  nolo agent list --json",
+    "  nolo space list --json",
+    "  nolo agent pull agent-pub-01APPBUILDER00000001YAII3I",
+    "  nolo agent read agent-pub-01APPBUILDER00000001YAII3I",
+    '  nolo agent run frontend-implementer --msg "polish notifications"',
+    "  nolo agent bind-current agent-user-1-agent-1",
+    "  nolo agent runtime-doctor agent-user-1-agent-1",
+    '  nolo agent smoke-bound agent-user-1-agent-1 --msg "ping"',
+    '  nolo agent smoke-current agent-user-1-agent-1 --msg "ping"',
+    '  nolo chat --agent agent-pub-01APPBUILDER00000001YAII3I --msg "你好"',
+    "  nolo space read 01KKY77TT0DA9NY7TNW3R7255N --content-key page-user-id --brief",
+    "  nolo space delete --name-prefix rn_owner_verify_0504 --yes",
+    "  nolo table query --table 01ABCXYZ",
+    '  nolo table query --table meta-b2e06f801f-NOLOTASKBOARD --columns \'["title","status","owner","priority","codeStatus"]\' --no-base-fields --output items',
+    '  nolo table update-row --table meta-b2e06f801f-NOLOTASKBOARD --row 01ROWID --changes \'{"status":"已完成"}\'',
+    "  nolo task-run read-context --row-dbkey row-user-table-row",
+    "  nolo llama status",
+  ];
+
+  for (const group of GROUP_ORDER) {
+    const commands = COMMANDS.filter((entry) => entry.path[0] === group);
+    if (commands.length === 0) continue;
+    lines.push("", group);
+    for (const entry of commands) {
+      lines.push(`  ${entry.path.join(" ")}  ${entry.description}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+export function resolveCommand(args: string[]) {
+  const sorted = [...COMMANDS].sort((a, b) => b.path.length - a.path.length);
+  return sorted.find((entry) =>
+    entry.path.every((part, index) => args[index] === part)
+  );
+}

package/cli/connectorRunArtifact.ts

@@ -0,0 +1,145 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import type { MachineRunPermissionPolicy } from "../ai/agent/machineRunPermissions";
+
+type EnvLike = Record<string, string | undefined>;
+
+export type ConnectorRunArtifact = {
+  cwd: string;
+  exitStatus: "completed" | "failed";
+  collectedAt: string;
+  baseSha?: string | null;
+  headSha?: string | null;
+  changedFiles?: string[];
+  statusShort?: string;
+  diffStat?: string;
+  patchPreview?: string;
+  error?: string;
+  artifactError?: string;
+};
+
+const MAX_PATCH_PREVIEW_CHARS = 24_000;
+
+function normalizePath(value: string) {
+  return resolve(value.trim());
+}
+
+function resolveExistingCandidate(
+  value: string | undefined,
+  checked: string[],
+  label: string
+) {
+  const trimmed = value?.trim();
+  if (!trimmed) return null;
+  const normalized = normalizePath(trimmed);
+  if (existsSync(normalized)) return normalized;
+  checked.push(`${label}=${normalized}`);
+  return null;
+}
+
+export function resolveConnectorRunCwd(args: {
+  env?: EnvLike;
+  policy: MachineRunPermissionPolicy;
+  fallbackCwd?: string;
+}) {
+  const checked: string[] = [];
+  const candidates: Array<[string | undefined, string]> = [
+    [args.env?.NOLO_CONNECTOR_WORKDIR, "NOLO_CONNECTOR_WORKDIR"],
+    [args.env?.NOLO_AGENT_WORKDIR, "NOLO_AGENT_WORKDIR"],
+    [args.env?.NOLO_LOCAL_WORKTREE, "NOLO_LOCAL_WORKTREE"],
+    [args.policy.writableRoots[0], "writableRoots[0]"],
+    [args.fallbackCwd, "fallbackCwd"],
+    [process.env.PWD, "PWD"],
+    [process.cwd(), "process.cwd()"],
+  ];
+
+  for (const [value, label] of candidates) {
+    const resolved = resolveExistingCandidate(value, checked, label);
+    if (resolved) return resolved;
+  }
+
+  if (checked.length > 0) {
+    throw new Error(
+      `Connector run cwd does not exist. Checked: ${checked.join(", ")}`
+    );
+  }
+  throw new Error("Connector run cwd could not be resolved.");
+}
+
+async function runGit(
+  args: string[],
+  cwd: string,
+  options: { trim?: boolean } = {}
+): Promise<string | null> {
+  const proc = Bun.spawn(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+  });
+  const [stdout, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) return null;
+  return options.trim === false ? stdout.replace(/\r?\n$/, "") : stdout.trim();
+}
+
+export function parseStatusChangedFiles(statusShort: string | null): string[] {
+  if (!statusShort) return [];
+  return [...new Set(statusShort
+    .split(/\r?\n/)
+    .map((line) => {
+      const porcelainMatch = line.match(/^.{2} (.+)$/);
+      if (porcelainMatch?.[1]) return porcelainMatch[1].trim();
+      const trimmedMatch = line.match(/^[MADRCU?!]{1,2}\s+(.+)$/);
+      return trimmedMatch?.[1]?.trim() ?? "";
+    })
+    .map((line) => line.includes(" -> ") ? line.split(" -> ").at(-1) ?? line : line)
+    .filter(Boolean))];
+}
+
+export async function readConnectorGitHead(cwd: string): Promise<string | null> {
+  return runGit(["rev-parse", "HEAD"], cwd);
+}
+
+export async function collectConnectorRunArtifact(args: {
+  cwd: string;
+  baseSha?: string | null;
+  exitStatus: "completed" | "failed";
+  error?: string;
+}): Promise<ConnectorRunArtifact> {
+  const collectedAt = new Date().toISOString();
+  try {
+    const [headSha, statusShort, diffStat, patchText] = await Promise.all([
+      readConnectorGitHead(args.cwd),
+      runGit(["status", "--short"], args.cwd, { trim: false }),
+      runGit(["diff", "--stat"], args.cwd),
+      runGit(["diff", "--no-color", "--unified=3"], args.cwd),
+    ]);
+    const patchPreview = patchText && patchText.length > MAX_PATCH_PREVIEW_CHARS
+      ? `${patchText.slice(0, MAX_PATCH_PREVIEW_CHARS)}\n...[truncated ${patchText.length - MAX_PATCH_PREVIEW_CHARS} chars]`
+      : patchText || undefined;
+    return {
+      cwd: args.cwd,
+      exitStatus: args.exitStatus,
+      collectedAt,
+      baseSha: args.baseSha ?? null,
+      headSha,
+      changedFiles: parseStatusChangedFiles(statusShort),
+      ...(statusShort ? { statusShort } : {}),
+      ...(diffStat ? { diffStat } : {}),
+      ...(patchPreview ? { patchPreview } : {}),
+      ...(args.error ? { error: args.error } : {}),
+    };
+  } catch (error) {
+    return {
+      cwd: args.cwd,
+      exitStatus: args.exitStatus,
+      collectedAt,
+      baseSha: args.baseSha ?? null,
+      ...(args.error ? { error: args.error } : {}),
+      artifactError: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/cli/connectorWebSocketTarget.ts

@@ -0,0 +1,109 @@
+export class ConnectorWebSocketAuthError extends Error {
+  code: string;
+
+  constructor(message: string, code = "CONNECTOR_AUTH_FAILED") {
+    super(message);
+    this.name = "ConnectorWebSocketAuthError";
+    this.code = code;
+  }
+}
+
+export function isConnectorWebSocketAuthError(error: unknown): error is ConnectorWebSocketAuthError {
+  return error instanceof ConnectorWebSocketAuthError;
+}
+
+export class ConnectorWebSocketRetryableError extends Error {
+  reason: string;
+  retryAfterMs?: number;
+
+  constructor(message: string, options: { reason?: string; retryAfterMs?: number } = {}) {
+    super(message);
+    this.name = "ConnectorWebSocketRetryableError";
+    this.reason = options.reason ?? "retryable";
+    this.retryAfterMs = options.retryAfterMs;
+  }
+}
+
+export function isConnectorWebSocketRetryableError(
+  error: unknown
+): error is ConnectorWebSocketRetryableError {
+  return error instanceof ConnectorWebSocketRetryableError;
+}
+
+function parseRetryAfterMs(response: Response, bodyRetryAfterMs?: unknown) {
+  const headerValue = response.headers.get("Retry-After");
+  if (typeof headerValue === "string" && headerValue.trim()) {
+    const asSeconds = Number(headerValue.trim());
+    if (Number.isFinite(asSeconds) && asSeconds >= 0) {
+      return Math.round(asSeconds * 1_000);
+    }
+    const asDateMs = Date.parse(headerValue.trim());
+    if (Number.isFinite(asDateMs)) {
+      return Math.max(0, asDateMs - Date.now());
+    }
+  }
+  const parsed = Number(bodyRetryAfterMs);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.round(parsed) : undefined;
+}
+
+export async function resolveConnectorWebSocketTarget(input: {
+  serverUrl: string;
+  machineId: string;
+  connectorSurface?: 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);
+  if (input.connectorSurface?.trim()) {
+    directWsUrl.searchParams.set("connectorSurface", input.connectorSurface.trim().toLowerCase());
+  }
+
+  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.status === 401 || response.status === 403)) {
+    const json = await response.json().catch(() => null);
+    const code = typeof json?.code === "string" ? json.code : "CONNECTOR_AUTH_FAILED";
+    const message = typeof json?.error === "string" ? json.error : `Connector auth failed with HTTP ${response.status}`;
+    throw new ConnectorWebSocketAuthError(`${code}: ${message}`, code);
+  }
+
+  if (response && !response.ok) {
+    const json = await response.clone().json().catch(() => null);
+    const retryable =
+      json?.retryable === true ||
+      json?.reason === "core_draining" ||
+      response.status === 502 ||
+      response.status === 503 ||
+      response.status === 504;
+    if (retryable) {
+      const reason = typeof json?.reason === "string" ? json.reason : "retryable";
+      const message =
+        typeof json?.error === "string"
+          ? json.error
+          : `Connector websocket unavailable with HTTP ${response.status}`;
+      throw new ConnectorWebSocketRetryableError(message, {
+        reason,
+        retryAfterMs: parseRetryAfterMs(response, json?.retryAfterMs),
+      });
+    }
+  }
+
+  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();
+}