nolo-cli 0.1.31 → 0.1.32

package/cli/client/agentRunRuntimeSelection.ts

@@ -0,0 +1,145 @@
+import type { AgentRuntimeRequestedMode } from "../agentRuntimeLocal";
+import {
+  isKnownPlatformAgentKey,
+} from "../agentAliases";
+import type { EnvLike } from "../cliEnvHelpers";
+import type { OutputLike } from "../cliIoTypes";
+export type { OutputLike } from "../cliIoTypes";
+
+export type ScriptBridgeDecision = {
+  hasAuthToken: boolean;
+  scriptPathExists: boolean;
+};
+
+export type RuntimeSelectionAgentConfig = {
+  toolNames?: string[];
+  runtimeToolPolicy?: {
+    agentTools?: string[];
+  };
+};
+
+export type RuntimeSelectionAdapter = {
+  loadAgentConfig(agentKey: string): Promise<RuntimeSelectionAgentConfig | undefined>;
+};
+
+export type RuntimeSelectionOptions = {
+  agentKey: string;
+  env: EnvLike;
+  output: OutputLike;
+  runtimeMode?: AgentRuntimeRequestedMode;
+  localRuntimeAdapter?: RuntimeSelectionAdapter;
+  localRuntimeAdapterFactory?: unknown;
+  resolveLocalRuntimeAdapter?: () => RuntimeSelectionAdapter | undefined;
+};
+
+const SERVER_PLATFORM_TOOL_NAMES = new Set([
+  "addTableRow",
+  "addTableRows",
+  "deleteTableRow",
+  "deleteTableRows",
+  "queryTableRows",
+  "streamParallelAgents",
+  "taskRun",
+  "updateTableRow",
+  "updateTableRows",
+]);
+
+const KNOWN_SERVER_PLATFORM_AGENT_ALIASES = new Set([
+  "code-review",
+  "frontend",
+  "frontend-agent",
+  "frontend-implementer",
+  "full-stack",
+  "fullstack",
+  "nolo code review",
+  "nolo frontend",
+  "nolo fullstack",
+  "nolo reviewer",
+  "nolo-code-review",
+  "nolo-frontend",
+  "nolo-fullstack",
+  "nolo-reviewer",
+  "review",
+  "reviewer",
+]);
+
+export function shouldUseScriptBridge(decision: ScriptBridgeDecision) {
+  return !decision.hasAuthToken && decision.scriptPathExists;
+}
+
+export function findServerPlatformTools(toolNames?: string[]) {
+  if (!Array.isArray(toolNames)) return [];
+  return toolNames.filter((toolName) => SERVER_PLATFORM_TOOL_NAMES.has(toolName));
+}
+
+export function resolveServerPlatformToolNames(agentConfig: RuntimeSelectionAgentConfig | undefined) {
+  return findServerPlatformTools([
+    ...(Array.isArray(agentConfig?.toolNames) ? agentConfig.toolNames : []),
+    ...(Array.isArray(agentConfig?.runtimeToolPolicy?.agentTools)
+      ? agentConfig.runtimeToolPolicy.agentTools
+      : []),
+  ]);
+}
+
+export function normalizeAgentRef(ref?: string) {
+  return ref?.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+export function isKnownServerPlatformAgent(options: Pick<RuntimeSelectionOptions, "agentKey">) {
+  if (isKnownPlatformAgentKey(options.agentKey)) return true;
+  const normalizedKey = normalizeAgentRef(options.agentKey);
+  return Boolean(normalizedKey && KNOWN_SERVER_PLATFORM_AGENT_ALIASES.has(normalizedKey));
+}
+
+export function shouldShowUsage(env: EnvLike) {
+  return env.NOLO_DEBUG === "1" || env.NOLO_SHOW_USAGE === "1";
+}
+
+export function resolveRequestedRuntimeMode(
+  options: Pick<RuntimeSelectionOptions, "env" | "runtimeMode">
+) {
+  const envMode = options.env.NOLO_RUNTIME_MODE;
+  if (options.runtimeMode) return options.runtimeMode;
+  if (envMode === "local" || envMode === "server" || envMode === "auto") return envMode;
+  return "auto";
+}
+
+export function shouldAttemptAutoLocal(
+  options: Pick<RuntimeSelectionOptions, "env" | "localRuntimeAdapter" | "localRuntimeAdapterFactory">
+) {
+  if (options.localRuntimeAdapter || options.localRuntimeAdapterFactory) return true;
+  return Boolean(
+    options.env.NOLO_LOCAL_OPENAI_API_KEY ||
+      options.env.OPENAI_API_KEY ||
+      options.env.NOLO_LOCAL_OPENAI_BASE_URL ||
+      options.env.OPENAI_BASE_URL ||
+      options.env.NOLO_LOCAL_AGENT_KEY
+  );
+}
+
+export async function shouldSkipAutoLocalForServerPlatformTools(
+  options: RuntimeSelectionOptions
+) {
+  if (isKnownServerPlatformAgent(options)) {
+    options.output.write(
+      `[nolo] auto runtime: skipping local runtime because ${options.agentKey} is a known platform agent. ` +
+        "Use --local explicitly to force local workspace tools.\n"
+    );
+    return true;
+  }
+  const adapter = options.localRuntimeAdapter || options.resolveLocalRuntimeAdapter?.();
+  if (!adapter) return false;
+  let agentConfig;
+  try {
+    agentConfig = await adapter.loadAgentConfig(options.agentKey);
+  } catch {
+    return false;
+  }
+  const serverTools = resolveServerPlatformToolNames(agentConfig);
+  if (serverTools.length === 0) return false;
+  options.output.write(
+    `[nolo] auto runtime: skipping local runtime because ${options.agentKey} declares server platform tools ` +
+      `(${serverTools.join(", ")}). Use --local explicitly to force local workspace tools.\n`
+  );
+  return true;
+}

package/cli/client/agentRunServerTransport.ts

@@ -0,0 +1,397 @@
+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`);
+    const errorText = typeof data?.error === "string" ? data.error.trim() : "";
+    const messageText = typeof data?.message === "string" ? data.message.trim() : "";
+    const reasonText = typeof data?.reason === "string" ? data.reason.trim() : "";
+    if (errorText) options.output.write(`${errorText}\n`);
+    if (messageText && messageText !== errorText) options.output.write(`${messageText}\n`);
+    if (reasonText) options.output.write(`reason=${reasonText}\n`);
+    await recordTaskRunOutcome({
+      options,
+      status: "failed",
+      errorCode: `HTTP_${res.status}`,
+      resultSummary: messageText || errorText || 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;
+}