nolo-cli 0.1.32 → 0.1.33

package/client/agentRunRuntimeSelection.ts

@@ -1,145 +0,0 @@
-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/client/agentRunServerTransport.ts

@@ -1,397 +0,0 @@
-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;
-}