nolo-cli 0.1.29 → 0.1.31

package/client/agentRunInput.ts

@@ -0,0 +1,10 @@
+export function buildUserInputContent(message: string, imageUrls: string[] = []) {
+  if (imageUrls.length === 0) return message;
+  return [
+    ...(message.trim() ? [{ type: "text" as const, text: message }] : []),
+    ...imageUrls.map((url) => ({
+      type: "image_url" as const,
+      image_url: { url },
+    })),
+  ];
+}

package/client/agentRunLocalExecutor.ts

@@ -0,0 +1,179 @@
+import { runLocalAgentTurn, resolveHostRuntimeConfigFromEnv } from "../agentRuntimeLocal";
+import { LOCAL_AGENT_CONFIG_MISSING_CODE } from "../agent-runtime/localLoop";
+import type { LocalAgentToolEvent } from "../agent-runtime/localLoop";
+import { buildUserInputContent } from "./agentRunInput";
+import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
+import { prependTaskRunPrompt } from "./taskRunPrompt";
+import { recordTaskRunOutcome } from "./agentRunTaskRunRecorder";
+import {
+  formatToolTraceEvent,
+  nextLocalToolRoundLimit,
+  parseLocalToolRoundLimitError,
+  resolveLocalToolRoundRetryLimit,
+  shouldCollectLocalToolEvidence,
+  shouldTraceLocalTools,
+  summarizeLocalToolEvidence,
+} from "./agentRunLocalExecution";
+import type { RunAgentTurnOptions } from "./agentRun";
+
+export type LocalAgentTurnResult = {
+  exitCode: number;
+  dialogId?: string;
+  localError?: unknown;
+  toolEvidence?: ReturnType<typeof summarizeLocalToolEvidence>;
+};
+
+function buildDefaultLocalRuntimeAdapter(options: RunAgentTurnOptions) {
+  return createCliLocalRuntimeAdapter({
+    env: options.env,
+    hostRuntimeConfig: resolveHostRuntimeConfigFromEnv({
+      env: options.env,
+      surface: "cli-local",
+      workspaceBinding: "explicit-cwd",
+    }),
+    fetchImpl: options.fetchImpl,
+    cwd: options.localRuntimeCwd,
+    output: options.output,
+  });
+}
+
+export function resolveLocalRuntimeAdapter(options: RunAgentTurnOptions) {
+  return (
+    options.localRuntimeAdapter ||
+    options.localRuntimeAdapterFactory?.(options.env, { cwd: options.localRuntimeCwd }) ||
+    buildDefaultLocalRuntimeAdapter(options)
+  );
+}
+
+export function isMissingLocalAgentConfigError(error: unknown, agentRef: string) {
+  return Boolean(
+    error &&
+      typeof error === "object" &&
+      "code" in error &&
+      (error as { code?: string; agentRef?: string }).code === LOCAL_AGENT_CONFIG_MISSING_CODE &&
+      (error as { code?: string; agentRef?: string }).agentRef === agentRef
+  );
+}
+
+export async function runInjectedLocalAgentTurn(options: RunAgentTurnOptions) {
+  return runLocalAgentTurnWithAutoRoundExpansion(options, { reportFailure: true });
+}
+
+export async function refreshMissingLocalAgentConfig(options: RunAgentTurnOptions) {
+  const adapter = resolveLocalRuntimeAdapter(options);
+  if (!adapter) return false;
+  const agentConfig = await adapter.loadAgentConfig(options.agentKey);
+  return Boolean(agentConfig);
+}
+
+export async function runLocalAgentTurnWithAutoRoundExpansion(
+  options: RunAgentTurnOptions,
+  settings: { reportFailure: boolean }
+) {
+  const maxRetryLimit = resolveLocalToolRoundRetryLimit(options);
+  let currentMaxToolRounds = options.maxToolRounds;
+  let lastResult: Awaited<ReturnType<typeof runLocalAgentTurnForCli>> | null = null;
+
+  while (true) {
+    const attemptOptions = {
+      ...options,
+      ...(typeof currentMaxToolRounds === "number" ? { maxToolRounds: currentMaxToolRounds } : {}),
+    };
+    const result = await runLocalAgentTurnForCli(attemptOptions, { reportFailure: false });
+    lastResult = result;
+    if (result.exitCode === 0) return result;
+
+    const exhaustedRounds = parseLocalToolRoundLimitError(result.localError);
+    if (exhaustedRounds === null) break;
+
+    const nextMaxToolRounds = nextLocalToolRoundLimit(exhaustedRounds);
+    if (nextMaxToolRounds > maxRetryLimit) break;
+
+    options.output.write(
+      `[nolo] Local agent used all ${exhaustedRounds} tool rounds; retrying with ${nextMaxToolRounds}.\n`
+    );
+    currentMaxToolRounds = nextMaxToolRounds;
+  }
+
+  if (settings.reportFailure && lastResult?.localError) {
+    options.output.write(
+      `[nolo] Local agent run failed: ${
+        lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError)
+      }\n`
+    );
+    await recordTaskRunOutcome({
+      options,
+      status: "failed",
+      errorCode: "LOCAL_AGENT_FAILED",
+      resultSummary:
+        lastResult.localError instanceof Error ? lastResult.localError.message : String(lastResult.localError),
+      toolEvidence: lastResult.toolEvidence,
+    });
+  }
+  return lastResult ?? { exitCode: 1 };
+}
+
+export async function runLocalAgentTurnForCli(
+  options: RunAgentTurnOptions,
+  settings: { reportFailure: boolean }
+): Promise<LocalAgentTurnResult> {
+  const adapter = resolveLocalRuntimeAdapter(options);
+  if (!adapter) {
+    options.output.write("[nolo] Local runtime was requested but no local runtime adapter is available.\n");
+    return { exitCode: 1 };
+  }
+
+  options.output.write(`\n${options.agentName} -> working locally...\n`);
+  const toolEvents: LocalAgentToolEvent[] = [];
+  try {
+    const traceLocalTools = shouldTraceLocalTools(options);
+    const collectToolEvidence = shouldCollectLocalToolEvidence(options);
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: options.agentKey,
+      input: buildUserInputContent(
+        prependTaskRunPrompt(options.message, options.taskRunContext),
+        options.imageUrls
+      ),
+      continueDialogId: options.continueDialogId,
+      spaceId: options.spaceId,
+      category: options.category,
+      inheritedFromDialogKey: options.inheritedFromDialogKey,
+      parentDialogId: options.parentDialogId,
+      background: options.background,
+      noStream: options.noStream,
+      maxToolRounds: options.maxToolRounds,
+      ...(traceLocalTools || collectToolEvidence
+        ? {
+            onToolEvent: (event) => {
+              if (collectToolEvidence) toolEvents.push(event);
+              if (traceLocalTools) options.output.write(formatToolTraceEvent(event));
+            },
+          }
+        : {}),
+    });
+    const content = result.content.trim();
+    if (content) {
+      options.output.write(`\n${options.agentName} > ${content}\n`);
+    } else {
+      options.output.write(`\n${options.agentName} > (no text response)\n`);
+    }
+    await recordTaskRunOutcome({
+      options,
+      status: options.background ? "running" : "completed",
+      dialogId: result.dialogId,
+      ...(!options.background && content ? { resultSummary: content } : {}),
+      toolEvidence: summarizeLocalToolEvidence(toolEvents),
+    });
+    return { exitCode: 0, dialogId: result.dialogId };
+  } catch (error) {
+    if (settings.reportFailure) {
+      options.output.write(
+        `[nolo] Local agent run failed: ${
+          error instanceof Error ? error.message : String(error)
+        }\n`
+      );
+    }
+    return { exitCode: 1, localError: error, toolEvidence: summarizeLocalToolEvidence(toolEvents) };
+  }
+}

package/client/agentRunServerTransport.ts

@@ -0,0 +1,394 @@
+import type { EnvLike } from "../cliEnvHelpers";
+import type { OutputLike } from "../cliIoTypes";
+import { NOLO_CLUSTER_SERVERS, normalizeKnownServerOrigin } from "../database/config";
+import { createStreamingTextWriter } from "./streamingOutput";
+import { buildUserInputContent } from "./agentRunInput";
+import { recordTaskRunOutcome, type TaskRunRecorder } from "./agentRunTaskRunRecorder";
+import { shouldShowUsage } from "./agentRunRuntimeSelection";
+import { prependTaskRunPrompt, type TaskRunPromptContext } from "./taskRunPrompt";
+
+type ServerTransportOptionShape = {
+  agentName: string;
+  agentKey: string;
+  serverUrl: string;
+  message: string;
+  imageUrls?: string[];
+  continueDialogId?: string;
+  spaceId?: string;
+  category?: string;
+  inheritedFromDialogKey?: string;
+  parentDialogId?: string;
+  background?: boolean;
+  noStream?: boolean;
+  scriptDir: string;
+  env: EnvLike;
+  output: OutputLike;
+  maxToolRounds?: number;
+  timeoutMs?: number;
+  taskRunContext?: TaskRunPromptContext;
+  taskRunRecorder?: TaskRunRecorder<any>;
+  fetchImpl?: typeof fetch;
+};
+
+export type ServerTransportRunResult = {
+  exitCode: number;
+  dialogId?: string;
+  streamInterrupted?: boolean;
+};
+
+export function formatUsage(usage: any, dialogId: unknown) {
+  const parts: string[] = [];
+  if (typeof dialogId === "string" && dialogId) parts.push(`dialog=${dialogId}`);
+
+  const input = usage?.input_tokens ?? usage?.prompt_tokens ?? 0;
+  const output = usage?.output_tokens ?? usage?.completion_tokens ?? 0;
+  if (input || output) parts.push(`tokens=${input}+${output}`);
+
+  return parts.length ? `  (${parts.join("  ")})` : "";
+}
+
+export function isLikelyTransportConnectivityError(reason: string) {
+  return /Unable to connect|ConnectionRefused|ECONNREFUSED|Failed to connect|timed out|Timeout|network|socket|handshake|certificate/i
+    .test(reason);
+}
+
+export function buildTransportErrorHint(serverUrl: string, error: unknown) {
+  const endpoint = `${serverUrl}/api/agent/run`;
+  const reason = error instanceof Error ? error.message : String(error);
+
+  let detail =
+    `[nolo] Could not reach ${endpoint}.\n` +
+    `Reason: ${reason}\n`;
+
+  try {
+    const parsed = new URL(serverUrl);
+    if (parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost") {
+      detail +=
+        "If you meant local dev, start the local API first.\n" +
+        "Otherwise set NOLO_SERVER to a reachable server, or re-run `nolo login --server https://nolo.chat`.\n";
+      return detail;
+    }
+  } catch {
+    // Keep the generic hint below when serverUrl is not a valid absolute URL.
+  }
+
+  if (isLikelyTransportConnectivityError(reason)) {
+    detail +=
+      "If this command is running inside a sandboxed agent session, outbound network access may be blocked even when the host machine can reach the server.\n";
+  }
+  detail += "Check NOLO_SERVER / BASE_URL and make sure the configured server is reachable.\n";
+  return detail;
+}
+
+function normalizeServerOrigin(serverUrl: string) {
+  return normalizeKnownServerOrigin(serverUrl) ?? serverUrl.trim().replace(/\/+$/, "");
+}
+
+function resolveNormalizedClusterServers() {
+  return [...new Set(NOLO_CLUSTER_SERVERS.map(normalizeServerOrigin))];
+}
+
+function resolveClusterRetryServers(serverUrl: string) {
+  const current = normalizeServerOrigin(serverUrl);
+  const clusterServers = resolveNormalizedClusterServers();
+  if (!clusterServers.includes(current)) return [];
+  return clusterServers.filter((candidate) => candidate !== current);
+}
+
+function shouldRetryBoundMachineUnavailable(response: Response, data: any) {
+  return response.status === 409 && data?.reason === "bound_machine_unavailable";
+}
+
+function resolveBoundMachineHintedRetryServer(
+  serverUrl: string,
+  data: any,
+) {
+  const current = normalizeServerOrigin(serverUrl);
+  const clusterServers = resolveNormalizedClusterServers();
+  const rawCandidates = [
+    typeof data?.retryServerBase === "string" ? data.retryServerBase : "",
+    typeof data?.serverBase === "string" ? data.serverBase : "",
+  ];
+  for (const rawCandidate of rawCandidates) {
+    const trimmed = rawCandidate.trim();
+    if (!trimmed) continue;
+    const normalized = normalizeServerOrigin(trimmed);
+    if (normalized === current) continue;
+    if (clusterServers.includes(normalized)) return normalized;
+  }
+  return null;
+}
+
+function resolveBoundMachineRetryTargets(
+  serverUrl: string,
+  data: any,
+) {
+  const hinted = resolveBoundMachineHintedRetryServer(serverUrl, data);
+  const siblings = resolveClusterRetryServers(serverUrl);
+  return [...new Set([
+    ...(hinted ? [hinted] : []),
+    ...siblings,
+  ])];
+}
+
+async function readJsonSafely(response: Response) {
+  try {
+    return await response.json();
+  } catch {
+    return {};
+  }
+}
+
+export async function readStreamingAgentRun(
+  options: ServerTransportOptionShape,
+  res: Response,
+): Promise<ServerTransportRunResult> {
+  const reader = res.body?.getReader();
+  if (!reader) {
+    options.output.write("[nolo] Agent stream response did not include a readable body.\n");
+    return { exitCode: 1 };
+  }
+
+  const decoder = new TextDecoder();
+  const writer = createStreamingTextWriter({
+    write: (chunk) => options.output.write(chunk),
+  });
+  let buffer = "";
+  let content = "";
+  let dialogId: string | undefined;
+  let usage: any;
+  let hasPrintedLabel = false;
+
+  const printLabel = () => {
+    if (hasPrintedLabel) return;
+    options.output.write(`\n${options.agentName} > `);
+    hasPrintedLabel = true;
+  };
+
+  const handlePayload = (payload: any) => {
+    if (typeof payload?.dialogId === "string" && payload.dialogId.trim()) {
+      dialogId = payload.dialogId;
+    }
+    if (payload?.error || payload?.type === "error") {
+      throw new Error(String(payload.error || payload.message || "Agent stream failed"));
+    }
+    if (payload?.type === "done") {
+      usage = payload.usage;
+      return;
+    }
+    if (payload?.type === "dialog" || payload?.type === "status") {
+      return;
+    }
+
+    const chunk =
+      payload?.type === "text"
+        ? payload.content
+        : typeof payload?.chunk === "string"
+          ? payload.chunk
+          : "";
+    if (!chunk) return;
+
+    printLabel();
+    content += chunk;
+    writer.push(chunk);
+  };
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const events = buffer.split("\n\n");
+      buffer = events.pop() ?? "";
+
+      for (const event of events) {
+        const dataLines = event
+          .split("\n")
+          .filter((line) => line.startsWith("data:"))
+          .map((line) => line.slice(5).trim())
+          .filter(Boolean);
+        for (const raw of dataLines) {
+          handlePayload(JSON.parse(raw));
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const raw = buffer
+        .split("\n")
+        .find((line) => line.startsWith("data:"))
+        ?.slice(5)
+        .trim();
+      if (raw) handlePayload(JSON.parse(raw));
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (dialogId) {
+      options.output.write(
+        `\n[nolo] Agent stream transport interrupted after dialog ${dialogId} was created: ${message}\n`
+      );
+      options.output.write("[nolo] The agent run may still finish on the server; read the dialog before retrying.\n");
+      return { exitCode: 0, dialogId, streamInterrupted: true };
+    }
+    options.output.write(`\n[nolo] Agent stream failed: ${message}\n`);
+    return { exitCode: 1 };
+  } finally {
+    writer.flushAll();
+  }
+
+  if (!content) {
+    options.output.write(`\n${options.agentName} > (no text response)\n`);
+  } else {
+    options.output.write("\n");
+  }
+
+  const usageText = formatUsage(usage, dialogId);
+  if (usageText && shouldShowUsage(options.env)) options.output.write(`${usageText}\n`);
+  return {
+    exitCode: 0,
+    ...(dialogId ? { dialogId } : {}),
+  };
+}
+
+export async function runHttpAgentTurn(
+  options: ServerTransportOptionShape,
+  args: {
+    authToken: string;
+  }
+): Promise<ServerTransportRunResult> {
+  options.output.write(`\n${options.agentName} -> working...\n`);
+
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const requestBody = {
+    agentKey: options.agentKey,
+    userInput: buildUserInputContent(
+      prependTaskRunPrompt(options.message, options.taskRunContext),
+      options.imageUrls
+    ),
+    runtimeContext: {
+      surface: "cli",
+      host: "terminal",
+      runtime: "bun",
+      entrypoint: "nolo-cli",
+      capabilities: ["text-io", "streaming", "slash-commands"],
+      ...(options.taskRunContext
+        ? {
+            taskRun: {
+              rowDbKey: options.taskRunContext.rowDbKey,
+              ...(options.taskRunContext.taskRunId
+                ? { taskRunId: options.taskRunContext.taskRunId }
+                : {}),
+              ...(options.taskRunContext.workItemId
+                ? { workItemId: options.taskRunContext.workItemId }
+                : {}),
+              ...(options.taskRunContext.artifactIds?.length
+                ? { artifactIds: options.taskRunContext.artifactIds }
+                : {}),
+            },
+          }
+        : {}),
+    },
+    ...(options.continueDialogId ? { continueDialogId: options.continueDialogId } : {}),
+    ...(options.spaceId ? { spaceId: options.spaceId } : {}),
+    ...(options.category ? { category: options.category } : {}),
+    ...(options.inheritedFromDialogKey
+      ? { inheritedFromDialogKey: options.inheritedFromDialogKey }
+      : {}),
+    ...(options.parentDialogId ? { parentDialogId: options.parentDialogId } : {}),
+    ...(options.background ? { background: true } : {}),
+    ...(typeof options.maxToolRounds === "number" ? { maxRounds: options.maxToolRounds } : {}),
+    ...(typeof options.timeoutMs === "number" ? { timeoutMs: options.timeoutMs } : {}),
+    stream: !options.noStream && !options.background,
+  };
+  let res: Response;
+  try {
+    const serverTargets = [options.serverUrl];
+    res = new Response(null, { status: 500 });
+    for (let index = 0; index < serverTargets.length; index += 1) {
+      const serverUrl = serverTargets[index]!;
+      res = await fetchImpl(`${serverUrl}/api/agent/run`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${args.authToken}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(requestBody),
+      });
+      const contentType = res.headers.get("content-type") || "";
+      if (res.ok || contentType.includes("text/event-stream")) break;
+      const data = await readJsonSafely(res.clone());
+      if (!shouldRetryBoundMachineUnavailable(res, data)) break;
+      const retryTargets = resolveBoundMachineRetryTargets(serverUrl, data);
+      for (const retryTarget of retryTargets) {
+        if (serverTargets.includes(retryTarget)) continue;
+        serverTargets.push(retryTarget);
+      }
+      const retryTarget = serverTargets[index + 1];
+      if (!retryTarget) break;
+      options.output.write(
+        `[nolo] Bound runtime unavailable on ${normalizeServerOrigin(serverUrl)}; retrying ${normalizeServerOrigin(retryTarget)}.\n`
+      );
+    }
+  } catch (error) {
+    options.output.write(buildTransportErrorHint(options.serverUrl, error));
+    return { exitCode: 1 };
+  }
+
+  const contentType = res.headers.get("content-type") || "";
+  if (contentType.includes("text/event-stream") && res.body) {
+    const result = await readStreamingAgentRun(options, res);
+    await recordTaskRunOutcome({
+      options,
+      status: result.streamInterrupted
+        ? "running"
+        : result.exitCode === 0
+          ? "completed"
+          : "failed",
+      dialogId: result.dialogId,
+      ...(result.exitCode !== 0 ? { errorCode: "STREAM_FAILED" } : {}),
+    });
+    return result;
+  }
+
+  let data: any = {};
+  try {
+    data = await res.json();
+  } catch {
+    data = {};
+  }
+
+  if (!res.ok) {
+    options.output.write(`[nolo] Agent request failed: HTTP ${res.status}\n`);
+    if (data?.error || data?.message) {
+      options.output.write(`${data.error || data.message}\n`);
+    }
+    await recordTaskRunOutcome({
+      options,
+      status: "failed",
+      errorCode: `HTTP_${res.status}`,
+      resultSummary: String(data?.error || data?.message || "").trim() || undefined,
+    });
+    return { exitCode: 1 };
+  }
+
+  const content = String(data?.content ?? data?.message ?? "").trim();
+  if (content) {
+    options.output.write(`\n${options.agentName} > ${content}\n`);
+  } else {
+    options.output.write(`\n${options.agentName} > (no text response)\n`);
+  }
+
+  const usage = formatUsage(data?.usage, data?.dialogId);
+  if (usage && shouldShowUsage(options.env)) options.output.write(`${usage}\n`);
+  const result = {
+    exitCode: 0,
+    ...(typeof data?.dialogId === "string" && data.dialogId ? { dialogId: data.dialogId } : {}),
+  };
+  await recordTaskRunOutcome({
+    options,
+    status: options.background ? "running" : "completed",
+    dialogId: result.dialogId,
+    ...(!options.background && content ? { resultSummary: content } : {}),
+  });
+  return result;
+}