nolo-cli 0.1.45 → 0.1.47

package/machineWsSession.ts

@@ -1,213 +0,0 @@
-import type { HeartbeatLoopOptions } from "./connector-experimental/heartbeatLoop";
-import type { MachineHeartbeat } from "./connector-experimental/protocol";
-import {
-  isConnectorWebSocketAuthError,
-  isConnectorWebSocketRetryableError,
-} from "./connectorWebSocketTarget";
-
-type EnvLike = Record<string, string | undefined>;
-type OutputLike = { write(chunk: string): unknown };
-
-export type ConnectorWebSocketOptions = {
-  headers: Record<string, string>;
-  onMessage: (message: string) => void | Promise<void>;
-  sentMessages: string[];
-  signal?: AbortSignal;
-};
-
-export type RunMachineWsSessionResult = {
-  exitCode: number;
-  retryAfterMs?: number;
-  reconnectReason?: string;
-};
-
-const CONNECTOR_WS_KEEPALIVE_MS = 25_000;
-
-function buildConnectorKeepaliveMessage() {
-  return JSON.stringify({ type: "connector.keepalive", sentAt: Date.now() });
-}
-
-function resolveHeartbeatIntervalMs(env: EnvLike) {
-  const raw = Number(env.NOLO_CONNECT_HEARTBEAT_MS ?? "");
-  return Number.isFinite(raw) && raw > 0 ? raw : 30_000;
-}
-
-export async function defaultConnectWebSocket(
-  url: string,
-  options: ConnectorWebSocketOptions,
-) {
-  const WebSocketCtor = globalThis.WebSocket;
-  if (!WebSocketCtor) {
-    throw new Error("WebSocket is not available in this runtime");
-  }
-  await new Promise<void>((resolve, reject) => {
-    const ws = new WebSocketCtor(url, {
-      headers: options.headers,
-    } as any);
-    let opened = false;
-    let aborted = options.signal?.aborted ?? false;
-    let keepalive: ReturnType<typeof setInterval> | null = null;
-    const clearKeepalive = () => {
-      if (keepalive) {
-        clearInterval(keepalive);
-        keepalive = null;
-      }
-    };
-    const handleAbort = () => {
-      aborted = true;
-      clearKeepalive();
-      try {
-        ws.close();
-      } catch {
-        resolve();
-      }
-    };
-    options.signal?.addEventListener("abort", handleAbort, { once: true });
-    ws.addEventListener(
-      "open",
-      () => {
-        opened = true;
-        keepalive = setInterval(() => {
-          try {
-            ws.send(buildConnectorKeepaliveMessage());
-          } catch {
-            clearKeepalive();
-          }
-        }, CONNECTOR_WS_KEEPALIVE_MS);
-      },
-      { once: true },
-    );
-    ws.addEventListener("error", () => {
-      clearKeepalive();
-      if (aborted) {
-        resolve();
-        return;
-      }
-      reject(new Error("connector websocket failed"));
-    });
-    ws.addEventListener(
-      "close",
-      () => {
-        clearKeepalive();
-        if (opened || aborted) resolve();
-        else reject(new Error("connector websocket closed before opening"));
-      },
-      { once: true },
-    );
-    ws.addEventListener("message", (event) => {
-      const startIndex = options.sentMessages.length;
-      Promise.resolve(options.onMessage(String(event.data)))
-        .then(() => {
-          for (const message of options.sentMessages.slice(startIndex)) {
-            ws.send(message);
-          }
-        })
-        .catch(() => undefined);
-    });
-  });
-}
-
-export async function runMachineWsSession(options: {
-  env: EnvLike;
-  output: OutputLike;
-  machine: MachineHeartbeat;
-  serverUrl: string;
-  authToken: string;
-  signal?: AbortSignal;
-  sendHeartbeat: () => Promise<void>;
-  runHeartbeatLoop: (options: HeartbeatLoopOptions) => Promise<void>;
-  resolveConnectorWebSocketTarget: (args: {
-    serverUrl: string;
-    machineId: string;
-    connectorSurface?: string;
-    headers: Record<string, string>;
-  }) => Promise<string>;
-  connectWebSocket: (url: string, options: ConnectorWebSocketOptions) => Promise<void>;
-  onMessage: (message: string, send: (message: string) => void) => void | Promise<void>;
-}): Promise<RunMachineWsSessionResult> {
-  const sentMessages: string[] = [];
-  const heartbeatAbort = new AbortController();
-  let heartbeatLoopPromise: Promise<void> | null = null;
-  let websocketPromise: Promise<void> | null = null;
-  try {
-    if (options.signal?.aborted) {
-      return { exitCode: 0 };
-    }
-    await options.sendHeartbeat();
-    options.output.write(
-      `Connector websocket connected: ${options.machine.name} (${options.machine.machineId})\n`
-    );
-    heartbeatLoopPromise = options.runHeartbeatLoop({
-      intervalMs: resolveHeartbeatIntervalMs(options.env),
-      sendHeartbeat: options.sendHeartbeat,
-      signal: heartbeatAbort.signal,
-    });
-    const heartbeatMonitorPromise = heartbeatLoopPromise.then(() => {
-      if (!heartbeatAbort.signal.aborted) {
-        throw new Error("connector heartbeat loop ended unexpectedly");
-      }
-    });
-    const wsTarget = await options.resolveConnectorWebSocketTarget({
-      serverUrl: options.serverUrl,
-      machineId: options.machine.machineId,
-      connectorSurface: "cli",
-      headers: { Authorization: `Bearer ${options.authToken}` },
-    });
-    websocketPromise = options.connectWebSocket(wsTarget, {
-      headers: { Authorization: `Bearer ${options.authToken}` },
-      signal: options.signal,
-      sentMessages,
-      onMessage: (message) =>
-        options.onMessage(message, (response) => {
-          sentMessages.push(response);
-        }),
-    });
-    const abortPromise = options.signal
-      ? new Promise<"aborted">((resolve) => {
-          if (options.signal?.aborted) {
-            resolve("aborted");
-            return;
-          }
-          options.signal?.addEventListener("abort", () => resolve("aborted"), { once: true });
-        })
-      : null;
-    const raceResult = await Promise.race(
-      [websocketPromise, heartbeatMonitorPromise, abortPromise].filter(Boolean) as Promise<void | "aborted">[]
-    );
-    heartbeatAbort.abort();
-    await Promise.allSettled([websocketPromise, heartbeatLoopPromise]);
-    if (raceResult === "aborted") {
-      return { exitCode: 0 };
-    }
-    return { exitCode: 0 };
-  } catch (error) {
-    heartbeatAbort.abort();
-    await Promise.allSettled(
-      [websocketPromise, heartbeatLoopPromise].filter(Boolean) as Promise<void>[],
-    );
-    if (isConnectorWebSocketAuthError(error)) {
-      options.output.write(
-        `[nolo] Connector websocket auth failed: ${error.message}. Re-register this machine or update NOLO_MACHINE_API_KEY.\n`
-      );
-      return { exitCode: 2 };
-    }
-    if (isConnectorWebSocketRetryableError(error)) {
-      const description =
-        error.reason === "core_draining" ? "core draining" : error.reason;
-      options.output.write(
-        `[nolo] Connector websocket unavailable: ${description} (${error.message}).\n`
-      );
-      return {
-        exitCode: 1,
-        retryAfterMs: error.retryAfterMs,
-        reconnectReason: error.reason,
-      };
-    }
-    options.output.write(
-      `[nolo] Connector websocket failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return { exitCode: 1 };
-  }
-}

package/memoryCommands.ts

@@ -1,253 +0,0 @@
-import type { AgentCommandDeps } from "./agentCommandSupport";
-import {
-  readOption,
-  resolveAuthToken,
-  resolveServerCandidates,
-  resolveServerUrl,
-} from "./cliEnvHelpers";
-
-const VALUE_FLAGS = new Set([
-  "--facet",
-  "--id",
-  "--ids",
-  "--kind",
-  "--limit",
-  "--pattern-prefix",
-  "--server",
-  "--server-url",
-  "--source-dialog",
-  "--subject",
-  "--subject-id",
-  "--subject-type",
-  "--tag",
-  "--token",
-]);
-
-function hasFlag(args: string[], flag: string) {
-  return args.includes(flag);
-}
-
-function printMemoryDeleteUsage(output: { write(chunk: string): unknown }) {
-  output.write(`Usage:
-  nolo memory delete --source-dialog <dialogId> --yes [--json]
-  nolo memory delete --tag <tag> --kind <kind> --yes
-  nolo memory delete --pattern-prefix <prefix> --limit <n> --yes
-
-Options:
-  --id <memoryId>            Delete a specific memory id. Repeatable.
-  --ids <a,b,c>              Delete specific memory ids.
-  --source-dialog <dialogId> Delete memories created from one dialog.
-  --tag <tag>                Require a tag. Repeatable.
-  --kind <kind>              Filter episodic / semantic / procedural. Repeatable.
-  --facet <facet>            Filter preference / tension / unfinished / goal / style. Repeatable.
-  --subject-type <type>      Filter user / agent / space / project / system.
-  --subject <subjectId>      Filter subjectId.
-  --pattern-prefix <prefix>  Filter patternKey prefix.
-  --limit <n>                Maximum memories to delete.
-  --yes                      Actually delete. Without this, command is a dry-run.
-  --json                     Print machine-readable JSON.
-  --server <url>             Prefer this server and include known Nolo peers.
-  --token <jwt>              Override AUTH_TOKEN.
-
-At least one filter is required; this command will not delete all memory implicitly.
-`);
-}
-
-function readRepeated(args: string[], flag: string) {
-  const values: string[] = [];
-  for (let index = 0; index < args.length; index += 1) {
-    if (args[index] !== flag) continue;
-    const value = args[index + 1];
-    if (typeof value === "string" && value.trim()) values.push(value.trim());
-  }
-  return values;
-}
-
-function readCsvValues(args: string[], flag: string) {
-  const raw = readRepeated(args, flag).join(",");
-  return raw
-    .split(",")
-    .map((value) => value.trim())
-    .filter(Boolean);
-}
-
-function readLimit(args: string[]) {
-  const raw = readOption(args, "--limit");
-  if (!raw) return undefined;
-  if (!/^\d+$/.test(raw)) throw new Error(`invalid --limit: ${raw}`);
-  const parsed = Number(raw);
-  return parsed > 0 ? parsed : undefined;
-}
-
-function assertNoUnknownFlags(args: string[]) {
-  for (let index = 0; index < args.length; index += 1) {
-    const value = args[index];
-    if (!value.startsWith("-")) continue;
-    if (value === "--help" || value === "-h" || value === "--yes" || value === "--json") continue;
-    if (VALUE_FLAGS.has(value)) {
-      index += 1;
-      continue;
-    }
-    throw new Error(`unknown option: ${value}`);
-  }
-}
-
-function buildDeleteBody(args: string[]) {
-  const ids = [...readRepeated(args, "--id"), ...readCsvValues(args, "--ids")];
-  const kinds = readRepeated(args, "--kind");
-  const facets = readRepeated(args, "--facet");
-  const tags = readRepeated(args, "--tag");
-  const sourceDialogId = readOption(args, "--source-dialog")?.trim();
-  const subjectType = readOption(args, "--subject-type")?.trim();
-  const subjectId = (readOption(args, "--subject") ?? readOption(args, "--subject-id"))?.trim();
-  const patternKeyPrefix = readOption(args, "--pattern-prefix")?.trim();
-  const limit = readLimit(args);
-
-  const body: Record<string, unknown> = {};
-  if (ids.length) body.ids = [...new Set(ids)];
-  if (kinds.length) body.kinds = [...new Set(kinds)];
-  if (facets.length) body.facets = [...new Set(facets)];
-  if (tags.length) body.tags = [...new Set(tags)];
-  if (sourceDialogId) body.sourceDialogId = sourceDialogId;
-  if (subjectType) body.subjectType = subjectType;
-  if (subjectId) body.subjectId = subjectId;
-  if (patternKeyPrefix) body.patternKeyPrefix = patternKeyPrefix;
-  if (typeof limit === "number") body.limit = limit;
-  return body;
-}
-
-function hasDeleteFilter(body: Record<string, unknown>) {
-  return Object.keys(body).some((key) => key !== "limit");
-}
-
-async function postMemoryDelete(args: {
-  authToken: string;
-  body: Record<string, unknown>;
-  fetchImpl: typeof fetch;
-  serverUrl: string;
-}) {
-  const res = await args.fetchImpl(`${args.serverUrl}/api/memory/delete`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${args.authToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify(args.body),
-  });
-  const text = await res.text();
-  let payload: any = null;
-  try {
-    payload = text ? JSON.parse(text) : null;
-  } catch {
-    payload = { raw: text };
-  }
-  if (!res.ok || payload?.error) {
-    const message =
-      payload?.error?.message ??
-      payload?.message ??
-      payload?.error ??
-      `HTTP ${res.status}`;
-    throw new Error(`${message}`);
-  }
-  return payload;
-}
-
-export async function runMemoryDeleteCommand(
-  args: string[],
-  deps: AgentCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
-    printMemoryDeleteUsage(output);
-    return 0;
-  }
-
-  try {
-    assertNoUnknownFlags(args);
-    const authToken = resolveAuthToken(args, env);
-    if (!authToken) {
-      output.write("[nolo] memory delete requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
-      return 1;
-    }
-
-    const body = buildDeleteBody(args);
-    if (!hasDeleteFilter(body)) {
-      output.write("[nolo] memory delete requires at least one filter; use --help for examples.\n");
-      return 1;
-    }
-
-    const shouldDelete = hasFlag(args, "--yes");
-    const wantJson = hasFlag(args, "--json");
-    const fetchImpl = deps.fetchImpl ?? fetch;
-    const serverUrl = resolveServerUrl(args, env);
-    const serverUrls = resolveServerCandidates(args, env, serverUrl);
-
-    if (!shouldDelete) {
-      const payload = {
-        dryRun: true,
-        deleted: false,
-        targetServers: serverUrls,
-        request: body,
-        nextStep: "rerun with --yes to delete matching memories",
-      };
-      if (wantJson) {
-        output.write(`${JSON.stringify(payload, null, 2)}\n`);
-      } else {
-        output.write("dryRun: true\n");
-        output.write(`targetServers: ${serverUrls.join(", ")}\n`);
-        output.write(`request: ${JSON.stringify(body)}\n`);
-        output.write("rerun with --yes to delete matching memories\n");
-      }
-      return 0;
-    }
-
-    const deleteResults = [];
-    for (const target of serverUrls) {
-      try {
-        const result = await postMemoryDelete({
-          authToken,
-          body,
-          fetchImpl,
-          serverUrl: target,
-        });
-        deleteResults.push({ serverUrl: target, ok: true, result });
-      } catch (error) {
-        deleteResults.push({
-          serverUrl: target,
-          ok: false,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    }
-
-    const deletedCount = deleteResults.reduce(
-      (sum, item) => sum + (item.ok ? Number(item.result?.deletedCount ?? 0) : 0),
-      0
-    );
-    const payload = {
-      dryRun: false,
-      deleted: true,
-      deletedCount,
-      request: body,
-      targetServers: serverUrls,
-      deleteResults,
-    };
-    if (wantJson) {
-      output.write(`${JSON.stringify(payload, null, 2)}\n`);
-    } else {
-      output.write(`deletedCount: ${deletedCount}\n`);
-      for (const result of deleteResults) {
-        output.write(
-          result.ok
-            ? `${result.serverUrl}: ok deleted=${result.result?.deletedCount ?? 0}\n`
-            : `${result.serverUrl}: failed ${result.error}\n`
-        );
-      }
-    }
-    return deleteResults.some((result) => result.ok) ? 0 : 1;
-  } catch (error) {
-    output.write(`[nolo] memory delete failed: ${error instanceof Error ? error.message : String(error)}\n`);
-    return 1;
-  }
-}

package/memoryInternalCommandEntries.ts

@@ -1,9 +0,0 @@
-import type { CommandEntry } from "./cliCommandTypes";
-import { createEnvCommand } from "./cliCommandFactories";
-import { runMemoryDeleteCommand } from "./memoryCommands";
-
-export function getMemoryInternalCommandEntries(): CommandEntry[] {
-  return [
-    createEnvCommand(["memory", "delete"], "Delete long-term memories by filter", runMemoryDeleteCommand),
-  ];
-}