nolo-cli 0.1.32 → 0.1.34

package/tableCommands.ts

@@ -1,21 +1,8 @@
-import type { EnvLike } from "./tableQueryParsing";
-import type { OutputLike } from "./cliIoTypes";
-import {
-  formatOutput,
-  hasFlag,
-  parseJsonOption,
-  parseJsonOptionAlias,
-  parseJwtTenantId,
-  parseOutputMode,
-  parseTableArg,
-  readOption,
-  resolveAuthToken,
-  resolveServerUrl,
-} from "./tableQueryParsing";
-import {
-  buildTableQueryRequest,
-  mergeQueryShortcutFilters,
-} from "./tableQueryRequest";
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import { includeTableActivityColumns } from "./render/table/activityColumns";
+
+type EnvLike = Record<string, string | undefined>;
+type OutputLike = { write(chunk: string): unknown };
 
 type TableCommandDeps = {
   env?: EnvLike;
@@ -23,6 +10,121 @@ type TableCommandDeps = {
   fetchImpl?: typeof fetch;
 };
 
+type OutputMode = "full" | "raw" | "items" | "jsonl";
+
+function readOption(args: string[], flag: string): string {
+  for (let i = 0; i < args.length; i++) {
+    const value = args[i];
+    if (value === flag) return args[i + 1] ?? "";
+    if (value.startsWith(`${flag}=`)) return value.slice(flag.length + 1);
+  }
+  return "";
+}
+
+function hasFlag(args: string[], flag: string): boolean {
+  return args.includes(flag);
+}
+
+function parseJsonOption<T>(args: string[], flag: string): T | undefined {
+  const raw = readOption(args, flag);
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw) as T;
+  } catch (error) {
+    throw new Error(`${flag} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function parseJsonOptionAlias<T>(args: string[], primaryFlag: string, aliasFlag: string): T | undefined {
+  const primary = readOption(args, primaryFlag);
+  const alias = readOption(args, aliasFlag);
+  const raw = primary || alias;
+  if (!raw) return undefined;
+  try {
+    return JSON.parse(raw) as T;
+  } catch (error) {
+    const usedFlag = primary ? primaryFlag : aliasFlag;
+    throw new Error(`${usedFlag} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function parseOutputMode(raw: string): OutputMode {
+  if (!raw) return "full";
+  if (raw === "json") return "raw";
+  if (raw === "full" || raw === "raw" || raw === "items" || raw === "jsonl") return raw;
+  throw new Error(`--output must be one of full, raw, items, json, jsonl; got ${raw}`);
+}
+
+function parseTableArg(raw: string): { tenantId?: string; tableId?: string } {
+  const trimmed = raw.trim();
+  if (!trimmed) return {};
+  if (!trimmed.startsWith("meta-")) return { tableId: trimmed };
+  const parts = trimmed.split("-");
+  return {
+    tenantId: parts[1],
+    tableId: parts.slice(2).join("-"),
+  };
+}
+
+function resolveServerUrl(args: string[], env: EnvLike): string {
+  return (
+    readOption(args, "--server-url") ||
+    readOption(args, "--server") ||
+    readOption(args, "--base-url") ||
+    env.NOLO_SERVER_URL ||
+    env.NOLO_SERVER ||
+    env.BASE_URL ||
+    DEFAULT_NOLO_SERVER_URL
+  ).replace(/\/+$/, "");
+}
+
+function resolveAuthToken(args: string[], env: EnvLike): string {
+  return (
+    readOption(args, "--machine-key") ||
+    readOption(args, "--token") ||
+    env.AUTH_TOKEN ||
+    env.AUTH ||
+    ""
+  );
+}
+
+function parseJwtTenantId(token: string): string | undefined {
+  const [, payload] = token.split(".");
+  if (!payload) return undefined;
+  try {
+    const normalized = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const decoded = Buffer.from(normalized, "base64").toString("utf8");
+    const parsed = JSON.parse(decoded);
+    return typeof parsed.userId === "string" ? parsed.userId : typeof parsed.sub === "string" ? parsed.sub : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function formatOutput(input: { envelope: any; rawData: any; mode: OutputMode }): string {
+  if (input.mode === "full") return JSON.stringify(input.envelope, null, 2);
+  if (input.mode === "raw") return JSON.stringify(input.rawData, null, 2);
+  const items = Array.isArray(input.rawData?.items) ? input.rawData.items : input.rawData;
+  if (input.mode === "items") return JSON.stringify(items, null, 2);
+  return Array.isArray(items) ? items.map((item) => JSON.stringify(item)).join("\n") : JSON.stringify(items);
+}
+
+function mergeQueryShortcutFilters(args: string[], filters: Record<string, unknown> | undefined): Record<string, unknown> | undefined {
+  const row = readOption(args, "--row") || readOption(args, "--row-id");
+  const rowDbKey = readOption(args, "--row-dbkey");
+  const shortcutFilters: Record<string, unknown> = {};
+  if (row) {
+    if (row.startsWith("row-")) shortcutFilters.dbKey = row;
+    else shortcutFilters.rowId = row;
+  }
+  if (rowDbKey) shortcutFilters.dbKey = rowDbKey;
+  if (Object.keys(shortcutFilters).length === 0) return filters;
+  return {
+    ...(filters ?? {}),
+    ...shortcutFilters,
+  };
+}
+
 function usage(): string {
   return [
     "Usage:",
@@ -78,21 +180,19 @@ export async function runTableQueryCommand(args: string[], deps: TableCommandDep
         Authorization: `Bearer ${authToken}`,
         "Content-Type": "application/json",
       },
-      body: JSON.stringify(
-        buildTableQueryRequest({
-          tenantId,
-          tableId,
-          filters,
-          columns,
-          includeActivity: hasFlag(args, "--include-activity"),
-          includeBaseFields: !hasFlag(args, "--no-base-fields"),
-          hasSingleRowShortcut,
-          limit: readOption(args, "--limit"),
-          offset: readOption(args, "--offset"),
-          sortBy: readOption(args, "--sort-by"),
-          sortOrder: readOption(args, "--sort-order"),
-        })
-      ),
+      body: JSON.stringify({
+        tenantId,
+        tableId,
+        filters: filters ?? {},
+        columns: hasFlag(args, "--include-activity")
+          ? includeTableActivityColumns(columns)
+          : columns,
+        includeBaseFields: !hasFlag(args, "--no-base-fields"),
+        limit: Number(readOption(args, "--limit") || (hasSingleRowShortcut ? 1 : 20)),
+        offset: Number(readOption(args, "--offset") || 0),
+        sortBy: readOption(args, "--sort-by") || "updatedAt",
+        sortOrder: readOption(args, "--sort-order") === "asc" ? "asc" : "desc",
+      }),
     });
   } catch (error) {
     output.write(`[nolo] table query failed: ${error instanceof Error ? error.message : String(error)}\n`);

package/taskRunCommand.ts

@@ -1,11 +1,10 @@
-import type { EnvLike } from "./taskRunParsing";
-import type { OutputLike } from "./cliIoTypes";
-import { buildBody, usage } from "./taskRunActions";
-import {
-  loadTaskRunEnv,
-  resolveAuthToken,
-  resolveServerUrl,
-} from "./taskRunParsing";
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+type EnvLike = Record<string, string | undefined>;
+type OutputLike = { write(chunk: string): unknown };
 
 type TaskRunCommandDeps = {
   env?: EnvLike;
@@ -13,13 +12,211 @@ type TaskRunCommandDeps = {
   fetchImpl?: typeof fetch;
 };
 
-const DEFAULT_TASK_RUN_TIMEOUT_MS = 10 * 60 * 1000;
+function parseEnvFile(path: string): EnvLike {
+  if (!path || !existsSync(path)) return {};
+  const parsed: EnvLike = {};
+  for (const rawLine of readFileSync(path, "utf8").split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const index = line.indexOf("=");
+    if (index <= 0) continue;
+    const key = line.slice(0, index).trim();
+    let value = line.slice(index + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    if (key) parsed[key] = value;
+  }
+  return parsed;
+}
+
+function loadTaskRunEnv(env: EnvLike, options: { includeDefaultEnvFiles?: boolean } = {}) {
+  const envFileCandidates = [
+    env.NOLO_TASK_RUN_ENV_FILE,
+    env.NOLO_MACHINE_ENV_FILE,
+    ...(options.includeDefaultEnvFiles
+      ? ["/etc/nolo/machine-runner.env", join(homedir(), ".nolo", "machine-runner.env")]
+      : []),
+  ].filter((path): path is string => Boolean(path));
+  const fileEnv = Object.assign({}, ...envFileCandidates.map(parseEnvFile));
+  return { ...fileEnv, ...env };
+}
+
+function readOption(args: string[], flag: string) {
+  for (let i = 0; i < args.length; i++) {
+    const value = args[i];
+    if (value === flag) return args[i + 1] ?? "";
+    if (value.startsWith(`${flag}=`)) return value.slice(flag.length + 1);
+  }
+  return "";
+}
+
+function csv(raw: string) {
+  return raw.split(",").map((item) => item.trim()).filter(Boolean);
+}
+
+function optionalJson(args: string[], flag: string) {
+  const value = optional(args, flag);
+  if (!value) return undefined;
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`${flag} must be valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+function resolveServerUrl(args: string[], env: EnvLike) {
+  return (
+    readOption(args, "--server-url") ||
+    readOption(args, "--server") ||
+    readOption(args, "--base-url") ||
+    env.NOLO_SERVER_URL ||
+    env.NOLO_SERVER ||
+    env.BASE_URL ||
+    DEFAULT_NOLO_SERVER_URL
+  ).replace(/\/+$/, "");
+}
+
+function resolveAuthToken(args: string[], env: EnvLike) {
+  return (
+    readOption(args, "--machine-key") ||
+    readOption(args, "--token") ||
+    env.NOLO_TASK_RUN_TOKEN ||
+    env.NOLO_MACHINE_API_KEY ||
+    env.AUTH_TOKEN ||
+    env.AUTH ||
+    ""
+  );
+}
+
+function required(args: string[], flag: string) {
+  const value = readOption(args, flag).trim();
+  if (!value) throw new Error(`${flag} is required`);
+  return value;
+}
+
+function optional(args: string[], flag: string) {
+  const value = readOption(args, flag).trim();
+  return value || undefined;
+}
+
+function buildBody(command: string, args: string[]) {
+  const dbKey = required(args, "--row-dbkey");
+  if (command === "read-context" || command === "readTaskContext") {
+    return { action: "readTaskContext", dbKey };
+  }
+  if (command === "claim-work-item" || command === "claimWorkItem") {
+    return {
+      action: "claimWorkItem",
+      dbKey,
+      workItemId: required(args, "--work-item-id"),
+      agentKey: required(args, "--agent-key"),
+      role: optional(args, "--role"),
+    };
+  }
+  if (command === "record-agent-run" || command === "recordAgentRun") {
+    const toolTraceSummary = optionalJson(args, "--tool-trace-summary");
+    return {
+      action: "recordAgentRun",
+      dbKey,
+      ...(optional(args, "--run-id") ? { runId: optional(args, "--run-id") } : {}),
+      agentKey: required(args, "--agent-key"),
+      ...(optional(args, "--role") ? { role: optional(args, "--role") } : {}),
+      runStatus: required(args, "--run-status"),
+      ...(optional(args, "--work-item-id") ? { workItemId: optional(args, "--work-item-id") } : {}),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--result-summary") ? { resultSummary: optional(args, "--result-summary") } : {}),
+      ...(optional(args, "--error-code") ? { errorCode: optional(args, "--error-code") } : {}),
+      ...(optional(args, "--tools-used") ? { toolsUsed: csv(optional(args, "--tools-used")!) } : {}),
+      ...(toolTraceSummary ? { toolTraceSummary } : {}),
+    };
+  }
+  if (command === "set-blocker" || command === "setBlocker") {
+    return {
+      action: "setBlocker",
+      dbKey,
+      workItemId: optional(args, "--work-item-id"),
+      blocker: {
+        layer: required(args, "--layer"),
+        code: required(args, "--code"),
+        message: required(args, "--message"),
+      },
+    };
+  }
+  if (command === "clear-blocker" || command === "clearBlocker") {
+    return {
+      action: "clearBlocker",
+      dbKey,
+      blockerId: required(args, "--blocker-id"),
+      workItemId: optional(args, "--work-item-id"),
+    };
+  }
+  if (command === "submit-outcome" || command === "submitOutcome") {
+    return {
+      action: "submitOutcome",
+      dbKey,
+      workItemId: required(args, "--work-item-id"),
+      summary: required(args, "--summary"),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
+    };
+  }
+  if (command === "request-review" || command === "requestReview") {
+    return {
+      action: "requestReview",
+      dbKey,
+      workItemId: optional(args, "--work-item-id"),
+      reviewerAgentKey: required(args, "--reviewer-agent-key"),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--message") ? { message: optional(args, "--message") } : {}),
+      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
+    };
+  }
+  if (command === "record-review" || command === "recordReview") {
+    return {
+      action: "recordReview",
+      dbKey,
+      ...(optional(args, "--work-item-id") ? { workItemId: optional(args, "--work-item-id") } : {}),
+      reviewStatus: required(args, "--review-status"),
+      ...(optional(args, "--reviewer-agent-key")
+        ? { reviewerAgentKey: optional(args, "--reviewer-agent-key") }
+        : {}),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--findings") ? { findings: optional(args, "--findings") } : {}),
+      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
+    };
+  }
+  if (command === "close-work-item" || command === "complete-work-item" || command === "closeWorkItem" || command === "completeWorkItem") {
+    return {
+      action: "closeWorkItem",
+      dbKey,
+      workItemId: required(args, "--work-item-id"),
+      summary: required(args, "--summary"),
+      ...(optional(args, "--reason") ? { reason: optional(args, "--reason") } : {}),
+      ...(optional(args, "--dialog-id") ? { dialogId: optional(args, "--dialog-id") } : {}),
+      ...(optional(args, "--artifact-ids") ? { artifactIds: csv(optional(args, "--artifact-ids")!) } : {}),
+    };
+  }
+  throw new Error(`Unknown task-run command: ${command}`);
+}
 
-function resolveTaskRunTimeoutMs(env: EnvLike) {
-  const raw = env.NOLO_TASK_RUN_TIMEOUT_MS;
-  if (!raw) return DEFAULT_TASK_RUN_TIMEOUT_MS;
-  const value = Number(raw);
-  return Number.isFinite(value) && value > 0 ? value : DEFAULT_TASK_RUN_TIMEOUT_MS;
+function usage() {
+  return [
+    "Usage:",
+    "  nolo task-run read-context --row-dbkey <row>",
+    "  nolo task-run claim-work-item --row-dbkey <row> --work-item-id <id> --agent-key <agent> [--role <role>]",
+    "  nolo task-run record-agent-run --row-dbkey <row> --agent-key <agent> --run-status <status> [--tools-used <csv>]",
+    "  nolo task-run set-blocker --row-dbkey <row> [--work-item-id <id>] --layer <layer> --code <code> --message <message>",
+    "  nolo task-run clear-blocker --row-dbkey <row> --blocker-id <id> [--work-item-id <id>]",
+    "  nolo task-run submit-outcome --row-dbkey <row> --work-item-id <id> --summary <summary> [--dialog-id <id>]",
+    "  nolo task-run request-review --row-dbkey <row> --reviewer-agent-key <agent> [--work-item-id <id>]",
+    "  nolo task-run record-review --row-dbkey <row> [--work-item-id <id>] --review-status <passed|needs_changes|blocked> [--findings <text>]",
+    "  nolo task-run close-work-item --row-dbkey <row> --work-item-id <id> --summary <summary>",
+    "",
+  ].join("\n");
 }
 
 export async function runTaskRunCommand(args: string[], deps: TaskRunCommandDeps = {}) {
@@ -47,7 +244,6 @@ export async function runTaskRunCommand(args: string[], deps: TaskRunCommandDeps
   }
 
   const serverUrl = resolveServerUrl(args, env);
-  const timeoutMs = resolveTaskRunTimeoutMs(env);
   let response: Response;
   try {
     response = await fetchImpl(`${serverUrl}/api/task-run`, {
@@ -57,7 +253,6 @@ export async function runTaskRunCommand(args: string[], deps: TaskRunCommandDeps
         "Content-Type": "application/json",
       },
       body: JSON.stringify(body),
-      signal: AbortSignal.timeout(timeoutMs),
     });
   } catch (error) {
     output.write(`[nolo] task-run failed: ${error instanceof Error ? error.message : String(error)}\n`);