nolo-cli 0.1.18 → 0.1.20

package/tableCommands.ts

@@ -0,0 +1,181 @@
+import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
+
+type EnvLike = Record<string, string | undefined>;
+type OutputLike = { write(chunk: string): unknown };
+
+type TableCommandDeps = {
+  env?: EnvLike;
+  output?: OutputLike;
+  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 parseOutputMode(raw: string): OutputMode {
+  if (!raw) return "full";
+  if (raw === "full" || raw === "raw" || raw === "items" || raw === "jsonl") return raw;
+  throw new Error(`--output must be one of full, raw, items, 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, "--api-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 usage(): string {
+  return [
+    "Usage:",
+    "  nolo table query --table <tableId|metaKey> [--tenant-id <userId>] [--filters <json>] [--columns <json-array>] [--no-base-fields] [--output full|raw|items|jsonl]",
+    "",
+  ].join("\n");
+}
+
+export async function runTableQueryCommand(args: string[], deps: TableCommandDeps = {}): Promise<number> {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    output.write(usage());
+    return 0;
+  }
+
+  let outputMode: OutputMode;
+  let columns: string[] | undefined;
+  let filters: Record<string, unknown> | undefined;
+  try {
+    outputMode = parseOutputMode(readOption(args, "--output"));
+    columns = parseJsonOption<string[]>(args, "--columns");
+    filters = parseJsonOption<Record<string, unknown>>(args, "--filters");
+  } catch (error) {
+    output.write(`[nolo] table query failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+
+  const tableArg = parseTableArg(readOption(args, "--table"));
+  const authToken = resolveAuthToken(args, env);
+  const tenantId = readOption(args, "--tenant-id") || tableArg.tenantId || env.USER_ID || parseJwtTenantId(authToken);
+  const tableId = tableArg.tableId;
+  if (!tenantId || !tableId) {
+    output.write(usage());
+    return 1;
+  }
+  if (!authToken) {
+    output.write("[nolo] table query failed: AUTH_TOKEN is required.\n");
+    return 1;
+  }
+
+  const serverUrl = resolveServerUrl(args, env);
+  let response: Response;
+  try {
+    response = await fetchImpl(`${serverUrl}/api/table/query-rows`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        tenantId,
+        tableId,
+        filters: filters ?? {},
+        columns,
+        includeBaseFields: !hasFlag(args, "--no-base-fields"),
+        limit: Number(readOption(args, "--limit") || 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`);
+    return 1;
+  }
+
+  const text = await response.text();
+  let payload: any;
+  try {
+    payload = text ? JSON.parse(text) : {};
+  } catch {
+    output.write(text ? `${text}\n` : "");
+    return response.ok ? 0 : 1;
+  }
+  if (!response.ok || payload?.error) {
+    output.write(`[nolo] table query failed: ${payload?.error ?? response.statusText}\n`);
+    return 1;
+  }
+
+  const rawData = payload.rawData ?? payload;
+  output.write(`${formatOutput({ envelope: payload, rawData, mode: outputMode })}\n`);
+  return 0;
+}

package/taskRunCommand.ts

@@ -0,0 +1,237 @@
+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;
+  output?: OutputLike;
+  fetchImpl?: typeof fetch;
+};
+
+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 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, "--api-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 === "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 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 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 = {}) {
+  const env = loadTaskRunEnv(deps.env ?? process.env, { includeDefaultEnvFiles: deps.env === undefined });
+  const output = deps.output ?? process.stdout;
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  const command = args[0];
+  if (!command || command === "--help" || command === "-h") {
+    output.write(usage());
+    return 0;
+  }
+
+  let body: Record<string, unknown>;
+  try {
+    body = buildBody(command, args.slice(1));
+  } catch (error) {
+    output.write(`[nolo] task-run failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  if (!authToken) {
+    output.write("[nolo] task-run failed: AUTH_TOKEN or NOLO_MACHINE_API_KEY is required.\n");
+    return 1;
+  }
+
+  const serverUrl = resolveServerUrl(args, env);
+  let response: Response;
+  try {
+    response = await fetchImpl(`${serverUrl}/api/task-run`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${authToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+  } catch (error) {
+    output.write(`[nolo] task-run failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+
+  const text = await response.text();
+  output.write(text.trim() ? `${text.trim()}\n` : "");
+  return response.ok ? 0 : 1;
+}