nolo-cli 0.1.23 → 0.1.29

package/agentRecordCommands.ts

@@ -0,0 +1,141 @@
+import { resolveCliAgentKeyInput } from "./agentAliases";
+import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
+import {
+  buildUpdatedAgentRecord,
+  normalizeAgentRecordForOutput,
+  parseAgentUpdateArgs,
+  resolveAgentRecordFromHybridStore,
+  writeAgentRecord,
+} from "./agentRecordHelpers";
+import { parseUserIdFromAuthToken, resolveAuthToken } from "./cliEnvHelpers";
+
+export async function runAgentReadCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const agentInput = args[0]?.trim();
+  if (!agentInput || agentInput === "--help" || agentInput === "-h") {
+    output.write("Usage: nolo agent read <agent>\n");
+    return agentInput ? 0 : 1;
+  }
+
+  const authToken = resolveAuthToken(env);
+  if (!authToken) {
+    output.write("[nolo] agent read requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const agentKey = resolveCliAgentKeyInput(agentInput);
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+
+  try {
+    const result = await resolveAgentRecordFromHybridStore({
+      agentInput,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl,
+    });
+    if (!result) {
+      throw new Error(`agent not found: ${agentKey}`);
+    }
+    output.write(JSON.stringify({
+      ...normalizeAgentRecordForOutput(result.agentKey, authToken, result.record),
+      source: result.source,
+    }, null, 2));
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent read failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}
+
+export async function runAgentUpdateCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  let parsed;
+  try {
+    parsed = parseAgentUpdateArgs(args);
+  } catch (error) {
+    output.write(`[nolo] agent update failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+  if (!parsed) {
+    output.write(
+      "Usage: nolo agent update <agent> [--model <id>] [--cli-provider <provider>] [--api-source <source>] [--prompt <text> | --prompt-file <path> | --prompt-doc <pageKey>] [--tools <json>] [--copy-provider-from <agent>] [--field key=value]\n"
+    );
+    return args[0] ? 0 : 1;
+  }
+
+  const authToken = resolveAuthToken(env);
+  if (!authToken) {
+    output.write("[nolo] agent update requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const userId = parseUserIdFromAuthToken(authToken);
+  if (!userId) {
+    output.write("[nolo] agent update could not read userId from AUTH_TOKEN.\n");
+    return 1;
+  }
+
+  const db = deps.db ?? await getReadableCliDb(output);
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const fallbackFetchImpl = deps.fallbackFetchImpl;
+
+  try {
+    const built = await buildUpdatedAgentRecord({
+      parsed,
+      env,
+      db,
+      fetchImpl,
+      fallbackFetchImpl,
+      authToken,
+    });
+
+    await writeAgentRecord({
+      agentKey: built.agentKey,
+      authToken,
+      fallbackFetchImpl,
+      fetchImpl,
+      serverUrl: built.serverUrl,
+      userId,
+      record: built.nextRecord,
+    });
+    await db.put(built.agentKey, {
+      ...built.nextRecord,
+      dbKey: built.agentKey,
+      key: built.nextRecord?.key || built.agentKey,
+      serverOrigin: built.serverUrl,
+    });
+
+    output.write(JSON.stringify({
+      ok: true,
+      agentKey: built.agentKey,
+      baseUrl: built.serverUrl,
+      updates: built.updates,
+      record: built.nextRecord,
+    }, null, 2));
+    output.write("\n");
+    return 0;
+  } catch (error) {
+    output.write(
+      `[nolo] agent update failed: ${
+        error instanceof Error ? error.message : String(error)
+      }\n`
+    );
+    return 1;
+  }
+}

package/agentRecordHelpers.ts

@@ -0,0 +1,452 @@
+import { readFileSync } from "node:fs";
+import { resolveCliAgentKeyInput } from "./agentAliases";
+import type { CliKvDb } from "./client/hybridRecordStore";
+import { buildLocalAgentLookupKeys, shouldReadAgentKeyRemotely } from "./client/localAgentRecords";
+import {
+  parseUserIdFromAuthToken,
+  readOption,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+  type EnvLike,
+} from "./cliEnvHelpers";
+
+const PROVIDER_COPY_FIELDS = [
+  "apiSource",
+  "provider",
+  "cliProvider",
+  "model",
+  "customProviderUrl",
+  "apiKey",
+  "useServerProxy",
+  "inputPrice",
+  "outputPrice",
+] as const;
+
+function readRepeatedOption(args: string[], flag: string) {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] !== flag || !args[index + 1]) continue;
+    values.push(args[index + 1]);
+    index += 1;
+  }
+  return values;
+}
+
+function parseJsonishValue(raw: string) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+
+async function curlFetch(url: string, init?: RequestInit): Promise<Response> {
+  const method = init?.method ?? "GET";
+  const headers = new Headers(init?.headers ?? {});
+  const command = ["curl", "-sS", "-L", "-X", method];
+
+  headers.forEach((value, key) => {
+    command.push("-H", `${key}: ${value}`);
+  });
+
+  if (typeof init?.body === "string" && init.body.length > 0) {
+    command.push("--data", init.body);
+  }
+
+  command.push("-w", "\n__NOLO_STATUS__:%{http_code}", url);
+  const proc = Bun.spawn(command, { stdout: "pipe", stderr: "pipe" });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || `curl failed for ${url}`);
+  }
+
+  const marker = "\n__NOLO_STATUS__:";
+  const markerIndex = stdout.lastIndexOf(marker);
+  const body = markerIndex >= 0 ? stdout.slice(0, markerIndex) : stdout;
+  const statusText = markerIndex >= 0 ? stdout.slice(markerIndex + marker.length).trim() : "0";
+  const status = Number(statusText);
+  return new Response(body, {
+    status: Number.isFinite(status) ? status : 0,
+    headers: { "Content-Type": headers.get("Content-Type") ?? "application/json" },
+  });
+}
+
+function shouldUseCurlTransportFallback(error: unknown) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /Unable to connect|ConnectionRefused|ECONNREFUSED|Failed to connect|Was there a typo|timed out|Timeout|handshake|certificate|ECONNRESET|socket|network/i.test(message);
+}
+
+async function fetchWithTransportFallback(
+  url: string,
+  init: RequestInit,
+  options: { fallbackFetchImpl?: typeof fetch; fetchImpl: typeof fetch }
+): Promise<Response> {
+  try {
+    return await options.fetchImpl(url, init);
+  } catch (error) {
+    if (!shouldUseCurlTransportFallback(error)) throw error;
+    if (options.fallbackFetchImpl) {
+      return options.fallbackFetchImpl(url, init);
+    }
+    if (options.fetchImpl !== fetch) throw error;
+    return curlFetch(url, init);
+  }
+}
+
+export async function readAgentRecord(args: {
+  agentKey: string;
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+}) {
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.agentKey)}`,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${args.authToken}` },
+    },
+    args
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`read failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return data?.data ?? data;
+}
+
+export async function readDbRecord(args: {
+  dbKey: string;
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+}) {
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`,
+    {
+      method: "GET",
+      headers: { Authorization: `Bearer ${args.authToken}` },
+    },
+    args
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`read failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return data?.data ?? data;
+}
+
+export async function queryUserRecords(args: {
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  userId: string;
+  type: "agent" | "cybot" | "dialog";
+  limit?: number;
+}) {
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}${
+      typeof args.limit === "number" && Number.isFinite(args.limit) ? `?limit=${args.limit}` : ""
+    }`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${args.authToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ type: args.type }),
+    },
+    args
+  );
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`query failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return Array.isArray(data?.data?.data)
+    ? data.data.data
+    : Array.isArray(data?.data)
+      ? data.data
+      : [];
+}
+
+export async function writeAgentRecord(args: {
+  agentKey: string;
+  authToken: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  userId: string;
+  record: Record<string, any>;
+}) {
+  return writeDbRecord({
+    authToken: args.authToken,
+    dbKey: args.agentKey,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    record: args.record,
+    serverUrl: args.serverUrl,
+    userId: args.userId,
+  });
+}
+
+export async function writeDbRecord(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  userId: string;
+  record: Record<string, any>;
+}) {
+  const res = await fetchWithTransportFallback(`${args.serverUrl}/api/v1/db/write/`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      customKey: args.dbKey,
+      userId: args.userId,
+      data: {
+        ...args.record,
+        dbKey: args.dbKey,
+      },
+    }),
+  }, args);
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`write failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+}
+
+export async function deleteDbRecord(args: {
+  authToken: string;
+  dbKey: string;
+  fallbackFetchImpl?: typeof fetch;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  userId: string;
+}) {
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/delete/${encodeURIComponent(args.dbKey)}?userId=${encodeURIComponent(args.userId)}`,
+    {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${args.authToken}`,
+      },
+    },
+    args
+  );
+  const text = await res.text();
+  let data: any = {};
+  if (text) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = {};
+    }
+  }
+  if (res.status === 404) return "missing" as const;
+  if (!res.ok && res.status !== 204) {
+    throw new Error(`delete failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+  return "deleted" as const;
+}
+
+export async function resolveAgentRecordFromHybridStore(args: {
+  agentInput: string;
+  env: EnvLike;
+  db: CliKvDb;
+  fetchImpl: typeof fetch;
+  fallbackFetchImpl?: typeof fetch;
+}) {
+  const agentKey = resolveCliAgentKeyInput(args.agentInput);
+  const authToken = resolveAuthToken(args.env);
+  const defaultServerUrl = resolveServerUrl(args.env);
+
+  for (const key of buildLocalAgentLookupKeys({
+    agentRef: agentKey,
+    userId: parseUserIdFromAuthToken(authToken) || "local",
+  })) {
+    try {
+      const record = await args.db.get(key);
+      if (record && typeof record === "object") {
+        return {
+          agentKey: key,
+          record,
+          source: record?.serverOrigin ? "remote-cache" : "local-cache",
+        } as const;
+      }
+    } catch {
+      // local miss
+    }
+
+    if (!shouldReadAgentKeyRemotely(key)) continue;
+    for (const serverUrl of resolveServerCandidates(args.env, defaultServerUrl)) {
+      try {
+        const remoteRecord = await readAgentRecord({
+          agentKey: key,
+          authToken,
+          fallbackFetchImpl: args.fallbackFetchImpl,
+          fetchImpl: args.fetchImpl,
+          serverUrl,
+        });
+        const cached = { ...remoteRecord, dbKey: key, serverOrigin: serverUrl };
+        await args.db.put(key, cached);
+        return {
+          agentKey: key,
+          record: cached,
+          source: "remote-cache",
+        } as const;
+      } catch {
+        // try next
+      }
+    }
+  }
+
+  return null;
+}
+
+export function normalizeAgentRecordForOutput(agentKey: string, authToken: string, agent: any) {
+  return {
+    agentKey,
+    baseUrl: agent?.serverOrigin ?? null,
+    name: agent?.name,
+    greeting: agent?.greeting,
+    model: agent?.model,
+    provider: agent?.provider ?? agent?.apiSource ?? null,
+    cliProvider: agent?.cliProvider ?? null,
+    customProviderUrl: agent?.customProviderUrl ?? null,
+    tools: agent?.tools ?? [],
+    isPublic: agent?.isPublic,
+    authUserId: parseUserIdFromAuthToken(authToken),
+    userId: agent?.userId,
+    record: agent,
+  };
+}
+
+export function parseAgentUpdateArgs(args: string[]) {
+  const agentInput = readOption(args, "--agent") ?? readOption(args, "--id") ?? args[0]?.trim();
+  if (!agentInput || agentInput === "--help" || agentInput === "-h") return null;
+
+  const updates: Record<string, unknown> = {};
+  const model = readOption(args, "--model");
+  const cliProvider = readOption(args, "--cli-provider");
+  const apiSource = readOption(args, "--api-source");
+  const provider = readOption(args, "--provider");
+  const prompt = readOption(args, "--prompt");
+  const promptFile = readOption(args, "--prompt-file");
+  const promptDoc = readOption(args, "--prompt-doc");
+  const tools = readOption(args, "--tools");
+  const copyProviderFrom = readOption(args, "--copy-provider-from");
+  const name = readOption(args, "--name");
+
+  const promptSources = [prompt, promptFile, promptDoc].filter(Boolean);
+  if (promptSources.length > 1) {
+    throw new Error("--prompt / --prompt-file / --prompt-doc are mutually exclusive.");
+  }
+
+  if (model) updates.model = model;
+  if (cliProvider) updates.cliProvider = cliProvider;
+  if (apiSource) updates.apiSource = apiSource;
+  if (provider) updates.provider = provider;
+  if (prompt) updates.prompt = prompt;
+  if (promptFile) updates.prompt = readFileSync(promptFile, "utf8");
+  if (tools) updates.tools = parseJsonishValue(tools);
+  if (name) updates.name = name;
+
+  for (const entry of readRepeatedOption(args, "--field")) {
+    const index = entry.indexOf("=");
+    if (index <= 0) {
+      throw new Error(`--field must use key=value, received ${JSON.stringify(entry)}`);
+    }
+    updates[entry.slice(0, index)] = parseJsonishValue(entry.slice(index + 1));
+  }
+
+  if (Object.keys(updates).length === 0) {
+    if (!promptDoc && !copyProviderFrom) {
+      throw new Error("No updates provided. Use --model / --cli-provider / --api-source / --field key=value.");
+    }
+  }
+
+  return { agentInput, updates, promptDoc, copyProviderFrom };
+}
+
+export async function buildUpdatedAgentRecord(args: {
+  parsed: NonNullable<ReturnType<typeof parseAgentUpdateArgs>>;
+  env: EnvLike;
+  db: CliKvDb;
+  fetchImpl: typeof fetch;
+  fallbackFetchImpl?: typeof fetch;
+  authToken: string;
+}) {
+  const cached = await resolveAgentRecordFromHybridStore({
+    agentInput: args.parsed.agentInput,
+    env: args.env,
+    db: args.db,
+    fetchImpl: args.fetchImpl,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+  });
+  const agentKey = cached?.agentKey ?? resolveCliAgentKeyInput(args.parsed.agentInput);
+  const serverUrl = cached?.record?.serverOrigin ?? resolveServerUrl(args.env);
+  const currentRecord = await readAgentRecord({
+    agentKey,
+    authToken: args.authToken,
+    fallbackFetchImpl: args.fallbackFetchImpl,
+    fetchImpl: args.fetchImpl,
+    serverUrl,
+  });
+
+  if (args.parsed.copyProviderFrom) {
+    const providerSource = await resolveAgentRecordFromHybridStore({
+      agentInput: args.parsed.copyProviderFrom,
+      env: args.env,
+      db: args.db,
+      fetchImpl: args.fetchImpl,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+    });
+    if (!providerSource) {
+      throw new Error(`provider source agent not found: ${args.parsed.copyProviderFrom}`);
+    }
+    for (const field of PROVIDER_COPY_FIELDS) {
+      if (field in providerSource.record) {
+        args.parsed.updates[field] = providerSource.record[field];
+      }
+    }
+  }
+
+  if (args.parsed.promptDoc) {
+    const promptDoc = await readDbRecord({
+      dbKey: args.parsed.promptDoc,
+      authToken: args.authToken,
+      fallbackFetchImpl: args.fallbackFetchImpl,
+      fetchImpl: args.fetchImpl,
+      serverUrl,
+    });
+    const promptBody = typeof promptDoc?.content === "string" ? promptDoc.content : "";
+    if (!promptBody.trim()) {
+      throw new Error(`prompt doc is empty or unreadable: ${args.parsed.promptDoc}`);
+    }
+    args.parsed.updates.prompt = promptBody;
+  }
+
+  const nextRecord = {
+    ...currentRecord,
+    ...args.parsed.updates,
+    updatedAt: Date.now(),
+  };
+
+  return {
+    agentKey,
+    serverUrl,
+    nextRecord,
+    updates: args.parsed.updates,
+  };
+}