nolo-cli 0.1.22 → 0.1.26

package/agentRecordHelpers.ts

@@ -0,0 +1,395 @@
+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";
+}) {
+  const res = await fetchWithTransportFallback(
+    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}`,
+    {
+      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>;
+}) {
+  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.agentKey,
+      userId: args.userId,
+      data: {
+        ...args.record,
+        dbKey: args.agentKey,
+      },
+    }),
+  }, args);
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(`write failed: HTTP ${res.status} ${JSON.stringify(data)}`);
+  }
+}
+
+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,
+  };
+}

package/agentRunCommand.ts

@@ -3,6 +3,7 @@ import { runAgentTurn, type RunAgentTurnResult } from "./client/agentRun";
 import type { AgentRuntimeHostAdapter, AgentRuntimeRequestedMode } from "./agentRuntimeLocal";
 import { existsSync, readFileSync } from "node:fs";
 import { extname, resolve } from "node:path";
+import { parseSkillDocProtocol, type WorkflowReferenceConfig } from "./ai/skills/skillDocProtocol";
 import { resolveCliAgentKeyInput } from "./agentAliases";
 import {
   ensureWorkspacePackageLinks,
@@ -27,6 +28,7 @@ type AgentRunCommandDeps = {
   prepareTaskWorktree?: typeof prepareTaskWorktree;
   ensureWorkspacePackageLinks?: typeof ensureWorkspacePackageLinks;
   inspectLocalRunWorkspace?: typeof inspectLocalRunWorkspace;
+  resolveWorkflowReference?: typeof resolveWorkflowReference;
 };
 
 type LocalRunWorkspaceInspection = {
@@ -63,11 +65,17 @@ type ParsedAgentRunArgs = {
   traceTools: boolean;
   useTaskWorktree: boolean;
   taskRunContext?: TaskRunPromptContext;
+  workflowRef?: string;
+};
+
+type ResolvedWorkflowReference = {
+  ref: string;
+  content: string;
+  config?: Partial<WorkflowReferenceConfig>;
 };
 
 const DEFAULT_TEST_ROOT_DIALOG_ID = "01KN6V3MVEQA4Q1PNKVM2W7YY8";
 const DEFAULT_TEST_ROOT_DIALOG_KEY = `dialog-b2e06f801f-${DEFAULT_TEST_ROOT_DIALOG_ID}`;
-const DEFAULT_AGENT_SPACE_ID = "01KKY77TT0DA9NY7TNW3R7255N";
 const DEFAULT_TEST_DIALOG_CATEGORY_ID = "test-dialogs";
 
 function readFlagValue(args: string[], flag: string) {
@@ -171,6 +179,7 @@ export function parseAgentRunArgs(
     ...readRepeatedFlagValues(args, "--image-url"),
   ];
   const useTaskWorktree = args.includes("--worktree-task");
+  const workflowRef = readFlagValue(args, "--workflow");
   const taskRowDbKey = readFlagValue(args, "--task-row-dbkey");
   const artifactIds = readFlagValue(args, "--artifact-ids")
     ?.split(",")
@@ -183,6 +192,7 @@ export function parseAgentRunArgs(
     allowShell: args.includes("--dangerously-allow-shell"),
     traceTools: args.includes("--trace-tools"),
     useTaskWorktree,
+    ...(workflowRef ? { workflowRef } : {}),
     ...(taskRowDbKey
       ? {
           taskRunContext: {
@@ -198,7 +208,7 @@ export function parseAgentRunArgs(
     noStream: args.includes("--no-stream"),
     noDefaultTestRoot,
     ...(continueDialogId ? { continueDialogId } : {}),
-    ...(!continueDialogId ? { spaceId: spaceId ?? DEFAULT_AGENT_SPACE_ID } : {}),
+    ...(!continueDialogId && spaceId ? { spaceId } : {}),
     ...(category ? { category } : !continueDialogId && !noDefaultTestRoot ? { category: DEFAULT_TEST_DIALOG_CATEGORY_ID } : {}),
     ...(inheritedRef?.dialogKey ? { inheritedFromDialogKey: inheritedRef.dialogKey } : {}),
     ...(inheritedRef?.dialogId ? { parentDialogId: inheritedRef.dialogId } : {}),
@@ -208,6 +218,57 @@ export function parseAgentRunArgs(
   };
 }
 
+function workflowRefToCandidatePath(cwd: string, ref: string) {
+  const normalized = ref.trim();
+  if (!normalized) return "";
+  if (normalized.endsWith(".md") || normalized.includes("/") || normalized.includes("\\")) {
+    const directPath = resolve(cwd, normalized);
+    if (existsSync(directPath)) return directPath;
+  }
+  const fileName = normalized.replace(/[^a-zA-Z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "");
+  return resolve(cwd, "docs", "workflows", `${fileName}.md`);
+}
+
+export async function resolveWorkflowReference(ref: string, cwd = process.cwd()): Promise<ResolvedWorkflowReference> {
+  const path = workflowRefToCandidatePath(cwd, ref);
+  if (!path || !existsSync(path)) {
+    throw new Error(`Workflow reference not found: ${ref}`);
+  }
+  const markdown = readFileSync(path, "utf8");
+  const parsed = parseSkillDocProtocol(markdown);
+  return {
+    ref,
+    content: parsed.content,
+    ...(parsed.meta?.workflowConfig ? { config: parsed.meta.workflowConfig } : {}),
+  };
+}
+
+export function prependWorkflowReferencePrompt(message: string, workflow?: ResolvedWorkflowReference): string {
+  if (!workflow) return message;
+  const config = workflow.config;
+  return [
+    "AI-native workflow reference:",
+    "- This reference is guidance for the agent, not a central workflow engine.",
+    `- ref: ${workflow.ref}`,
+    ...(config?.id ? [`- id: ${config.id}`] : []),
+    ...(config?.name ? [`- name: ${config.name}`] : []),
+    ...(config?.defaultAgent ? [`- suggested defaultAgent: ${config.defaultAgent}`] : []),
+    ...(config?.inputs?.length ? [`- inputs: ${config.inputs.join(", ")}`] : []),
+    ...(config?.recommendedTools?.length ? [`- recommendedTools: ${config.recommendedTools.join(", ")}`] : []),
+    ...(config?.requiredTools?.length ? [`- requiredTools: ${config.requiredTools.join(", ")}`] : []),
+    ...(config?.requiredOutputs?.length ? [`- requiredOutputs: ${config.requiredOutputs.join(", ")}`] : []),
+    ...(config?.gates?.length ? [`- gates: ${config.gates.join(", ")}`] : []),
+    ...(config?.contextStrategy ? [`- contextStrategy: ${config.contextStrategy}`] : []),
+    ...(config?.failureProtocol ? [`- failureProtocol: ${config.failureProtocol}`] : []),
+    "",
+    "Reference body:",
+    workflow.content,
+    "",
+    "User task:",
+    message,
+  ].join("\n");
+}
+
 function parseDialogReference(rawInput: string) {
   const normalized = rawInput.trim();
   if (normalized.startsWith("dialog-")) {
@@ -353,6 +414,17 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
   }
 
   const runner = deps.runner ?? runAgentTurn;
+  let workflowReference: ResolvedWorkflowReference | undefined;
+  if (parsed.workflowRef) {
+    try {
+      workflowReference = await (deps.resolveWorkflowReference ?? resolveWorkflowReference)(
+        parsed.workflowRef
+      );
+    } catch (error) {
+      output.write(`[nolo] ${error instanceof Error ? error.message : String(error)}\n`);
+      return 1;
+    }
+  }
   let localRuntimeCwd = parsed.cwd;
   if (shouldPrepareTaskWorktree(parsed)) {
     try {
@@ -399,7 +471,7 @@ export async function runAgentRunCommand(args: string[], deps: AgentRunCommandDe
     agentName: parsed.agentKey,
     agentKey: parsed.agentKey,
     serverUrl: resolveServerUrl(env),
-    message: parsed.message,
+    message: prependWorkflowReferencePrompt(parsed.message, workflowReference),
     imageUrls: parsed.imageUrls.map(normalizeCliImageInput),
     scriptDir: deps.scriptDir,
     env: runEnv,