nolo-cli 0.1.32 → 0.1.34

package/cli/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;
-}

package/cli/client/agentRunTaskRunRecorder.ts

@@ -1,176 +0,0 @@
-import { join } from "node:path";
-
-import type { EnvLike } from "../cliEnvHelpers";
-import type { OutputLike } from "../cliIoTypes";
-import {
-  classifyTaskRunReviewStatus,
-  type TaskRunToolEvidence,
-} from "./agentRunLocalExecution";
-import type { TaskRunPromptContext } from "./taskRunPrompt";
-
-type TaskRunAgentRole = "pm" | "frontend" | "fullstack" | "reviewer" | "codex";
-type TaskRunStatus = "running" | "completed" | "failed";
-
-type TaskRunRecorderOptionShape = {
-  agentName: string;
-  agentKey: string;
-  serverUrl: string;
-  scriptDir: string;
-  env: EnvLike;
-  output: OutputLike;
-  taskRunContext?: TaskRunPromptContext;
-  taskRunRecorder?: unknown;
-};
-
-export type TaskRunRecorderArgs<
-  TOptions extends TaskRunRecorderOptionShape = TaskRunRecorderOptionShape,
-> = {
-  options: TOptions;
-  status: TaskRunStatus;
-  dialogId?: string;
-  resultSummary?: string;
-  errorCode?: string;
-  toolEvidence?: TaskRunToolEvidence;
-};
-
-export type TaskRunRecorder<
-  TOptions extends TaskRunRecorderOptionShape = TaskRunRecorderOptionShape,
-> = (args: TaskRunRecorderArgs<TOptions>) => Promise<void>;
-
-export function inferTaskRunAgentRole(agentRef: string): TaskRunAgentRole {
-  const normalized = agentRef.toLowerCase();
-  if (normalized.includes("project-manager") || normalized.includes("manager")) return "pm";
-  if (normalized.includes("frontend")) return "frontend";
-  if (normalized.includes("fullstack")) return "fullstack";
-  if (normalized.includes("review")) return "reviewer";
-  return "codex";
-}
-
-export async function runTaskRunCli<TOptions extends TaskRunRecorderOptionShape>(args: {
-  options: TOptions;
-  cliArgs: string[];
-}) {
-  const scriptPath = join(args.options.scriptDir, "taskRun.ts");
-  const proc = Bun.spawn({
-    cmd: [process.execPath, scriptPath, ...args.cliArgs],
-    stdout: "pipe",
-    stderr: "pipe",
-    env: {
-      ...process.env,
-      ...args.options.env,
-      BASE_URL: args.options.serverUrl,
-    },
-  });
-  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 || stdout || `taskRun.ts exited ${exitCode}`).trim());
-  }
-}
-
-export async function defaultTaskRunRecorder<TOptions extends TaskRunRecorderOptionShape>(
-  args: TaskRunRecorderArgs<TOptions>
-) {
-  const context = args.options.taskRunContext;
-  if (!context?.rowDbKey) return;
-  const role = inferTaskRunAgentRole(args.options.agentName || args.options.agentKey);
-  if (role === "reviewer" && args.status !== "running") {
-    await runTaskRunCli({
-      options: args.options,
-      cliArgs: [
-        "request-review",
-        "--row-dbkey",
-        context.rowDbKey,
-        "--base-url",
-        args.options.serverUrl,
-        "--reviewer-agent-key",
-        args.options.agentKey,
-        ...(context.artifactIds?.length ? ["--artifact-ids", context.artifactIds.join(",")] : []),
-        ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
-      ],
-    });
-  }
-  await runTaskRunCli({
-    options: args.options,
-    cliArgs: [
-      "record-agent-run",
-      "--row-dbkey",
-      context.rowDbKey,
-      "--base-url",
-      args.options.serverUrl,
-      "--agent-key",
-      args.options.agentKey,
-      "--role",
-      role,
-      "--run-status",
-      args.status,
-      ...(context.workItemId ? ["--work-item-id", context.workItemId] : []),
-      ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
-      ...(args.resultSummary ? ["--result-summary", args.resultSummary.slice(0, 240)] : []),
-      ...(args.errorCode ? ["--error-code", args.errorCode] : []),
-      ...(args.toolEvidence?.toolsUsed?.length
-        ? ["--tools-used", args.toolEvidence.toolsUsed.join(",")]
-        : []),
-      ...(args.toolEvidence?.summary
-        ? ["--tool-trace-summary", JSON.stringify(args.toolEvidence.summary)]
-        : []),
-    ],
-  });
-  if (context.workItemId && args.dialogId) {
-    await runTaskRunCli({
-      options: args.options,
-      cliArgs: [
-        "update-work-item",
-        "--row-dbkey",
-        context.rowDbKey,
-        "--base-url",
-        args.options.serverUrl,
-        "--id",
-        context.workItemId,
-        "--dialog-ids",
-        args.dialogId,
-      ],
-    });
-  }
-  if (role === "reviewer" && args.status !== "running") {
-    const reviewStatus =
-      args.status === "failed" ? "blocked" : classifyTaskRunReviewStatus(args.resultSummary);
-    if (reviewStatus) {
-      await runTaskRunCli({
-        options: args.options,
-        cliArgs: [
-          "review-result",
-          "--row-dbkey",
-          context.rowDbKey,
-          "--base-url",
-          args.options.serverUrl,
-          "--review-status",
-          reviewStatus,
-          "--reviewer-agent-key",
-          args.options.agentKey,
-          ...(context.artifactIds?.length ? ["--artifact-ids", context.artifactIds.join(",")] : []),
-          ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
-        ],
-      });
-    }
-  }
-}
-
-export async function recordTaskRunOutcome<TOptions extends TaskRunRecorderOptionShape>(
-  args: TaskRunRecorderArgs<TOptions>
-) {
-  if (!args.options.taskRunContext?.rowDbKey) return;
-  try {
-    const recorder =
-      (args.options.taskRunRecorder as TaskRunRecorder<TOptions> | undefined) ??
-      ((nextArgs: TaskRunRecorderArgs<TOptions>) => defaultTaskRunRecorder(nextArgs));
-    await recorder(args);
-  } catch (error) {
-    args.options.output.write(
-      `[nolo] task-run writeback failed: ${error instanceof Error ? error.message : String(error)}\n`
-    );
-  }
-}