nolo-cli 0.1.41 → 0.1.42

package/cli/qoderUsageProbe.ts

@@ -0,0 +1,252 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+export type QoderQuotaUsage = {
+  userId: string | null;
+  userType: string | null;
+  expiresAt: string | null;
+  expiresAtMs: number | null;
+  isQuotaExceeded: boolean | null;
+  totalUsagePercentage: number | null;
+  quota: {
+    total: number | null;
+    used: number | null;
+    remaining: number | null;
+    percentage: number | null;
+    unit: string | null;
+  };
+  source: "qoder-cli-log";
+  logPath?: string;
+  capturedAt?: string;
+  capturedAtMs?: number | null;
+};
+
+export type QoderUsageFreshness = "fresh" | "stale" | "uncertain";
+
+export type QoderUsageProbeResult = {
+  ok: boolean;
+  provider: "qoder";
+  usage?: (QoderQuotaUsage & { logPath: string });
+  limitations?: string[];
+  freshness?: QoderUsageFreshness;
+  ageSeconds?: number | null;
+  staleThresholdSeconds?: number;
+  scannedLogCount?: number;
+  reason?: string;
+  error?: string;
+};
+
+const QUOTA_RESPONSE_MARKER = "/api/v2/quota/usage response:";
+
+const asFiniteNumber = (value: unknown): number | null =>
+  typeof value === "number" && Number.isFinite(value) ? value : null;
+
+const asString = (value: unknown): string | null =>
+  typeof value === "string" && value.trim() ? value.trim() : null;
+
+const asBoolean = (value: unknown): boolean | null =>
+  typeof value === "boolean" ? value : null;
+
+function normalizeQuotaPayload(payload: any): QoderQuotaUsage | null {
+  if (!payload || typeof payload !== "object") return null;
+  const quota = payload.userQuota && typeof payload.userQuota === "object"
+    ? payload.userQuota
+    : {};
+  const expiresAtMs = asFiniteNumber(payload.expiresAt);
+  return {
+    userId: asString(payload.userId),
+    userType: asString(payload.userType),
+    expiresAt: expiresAtMs != null ? new Date(expiresAtMs).toISOString() : null,
+    expiresAtMs,
+    isQuotaExceeded: asBoolean(payload.isQuotaExceeded),
+    totalUsagePercentage: asFiniteNumber(payload.totalUsagePercentage),
+    quota: {
+      total: asFiniteNumber(quota.total),
+      used: asFiniteNumber(quota.used),
+      remaining: asFiniteNumber(quota.remaining),
+      percentage: asFiniteNumber(quota.percentage),
+      unit: asString(quota.unit),
+    },
+    source: "qoder-cli-log",
+  };
+}
+
+function isRealQuotaResponseLine(line: string): boolean {
+  const markerIndex = line.indexOf(QUOTA_RESPONSE_MARKER);
+  if (markerIndex < 0) return false;
+  const before = line.slice(0, markerIndex);
+  if (!before.includes("[qoderApi]")) return false;
+  const jsonStart = markerIndex + QUOTA_RESPONSE_MARKER.length;
+  const after = line.slice(jsonStart).trimStart();
+  return after.startsWith("{");
+}
+
+export function parseQoderQuotaUsageFromText(text: string): QoderQuotaUsage | null {
+  let latest: QoderQuotaUsage | null = null;
+  for (const line of text.split(/\r?\n/)) {
+    if (!isRealQuotaResponseLine(line)) continue;
+    const markerIndex = line.indexOf(QUOTA_RESPONSE_MARKER);
+    const jsonText = line.slice(markerIndex + QUOTA_RESPONSE_MARKER.length).trim();
+    try {
+      const parsed = normalizeQuotaPayload(JSON.parse(jsonText));
+      if (parsed) latest = parsed;
+    } catch {
+      // Ignore malformed historical log lines.
+    }
+  }
+  return latest;
+}
+
+export function extractLeadingIsoTimestamp(dirName: string): string | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})(?:-(\d{3}))?([+-])(\d{2})-(\d{2})/.exec(dirName);
+  if (!match) return null;
+  const [, Y, M, D, h, m, s, ms, sign, offH, offM] = match;
+  const local = Date.UTC(Number(Y), Number(M) - 1, Number(D), Number(h), Number(m), Number(s), Number(ms ?? 0));
+  const offsetMs = (Number(offH) * 60 + Number(offM)) * 60_000;
+  const utcMs = sign === "+" ? local - offsetMs : local + offsetMs;
+  if (!Number.isFinite(utcMs)) return null;
+  return new Date(utcMs).toISOString();
+}
+
+type RunLogEntry = {
+  logPath: string;
+  capturedAtMs: number | null;
+  capturedAt: string | null;
+  dirName: string;
+};
+
+function listQoderRunLogs(qoderHome: string): RunLogEntry[] {
+  const runsDir = join(qoderHome, "logs", "runs");
+  if (!existsSync(runsDir)) return [];
+  const entries: RunLogEntry[] = [];
+  for (const entry of readdirSync(runsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const logPath = join(runsDir, entry.name, "qodercli.log");
+    if (!existsSync(logPath)) continue;
+    const capturedAt = extractLeadingIsoTimestamp(entry.name);
+    const capturedAtMs = capturedAt ? Date.parse(capturedAt) : null;
+    entries.push({
+      logPath,
+      capturedAtMs,
+      capturedAt,
+      dirName: entry.name,
+    });
+  }
+  entries.sort((a, b) => {
+    const aMs = a.capturedAtMs ?? statSync(a.logPath).mtimeMs;
+    const bMs = b.capturedAtMs ?? statSync(b.logPath).mtimeMs;
+    return bMs - aMs;
+  });
+  return entries;
+}
+
+export function findLatestQoderQuotaUsage(options: {
+  qoderHome?: string;
+  now?: number;
+} = {}): (QoderQuotaUsage & { logPath: string; capturedAtMs: number | null; capturedAt: string | null }) | null {
+  const qoderHome = options.qoderHome || join(homedir(), ".qoder");
+  for (const run of listQoderRunLogs(qoderHome)) {
+    const parsed = parseQoderQuotaUsageFromText(readFileSync(run.logPath, "utf8"));
+    if (!parsed) continue;
+    return {
+      ...parsed,
+      logPath: run.logPath,
+      capturedAt: run.capturedAt,
+      capturedAtMs: run.capturedAtMs,
+    };
+  }
+  return null;
+}
+
+const DEFAULT_STALE_THRESHOLD_SECONDS = 6 * 60 * 60;
+
+export function classifyQoderUsageFreshness(
+  usage: { capturedAtMs: number | null } | null,
+  options: { now?: number; staleThresholdSeconds?: number } = {},
+): QoderUsageFreshness {
+  if (!usage || usage.capturedAtMs == null) return "uncertain";
+  const now = options.now ?? Date.now();
+  const threshold = (options.staleThresholdSeconds ?? DEFAULT_STALE_THRESHOLD_SECONDS) * 1000;
+  const age = now - usage.capturedAtMs;
+  if (!Number.isFinite(age) || age < 0) return "uncertain";
+  return age > threshold ? "stale" : "fresh";
+}
+
+function readOption(args: string[], flag: string) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+export async function runQoderUsageCommand(
+  args: string[],
+  deps: {
+    env?: Record<string, string | undefined>;
+    output?: { write(chunk: string): unknown };
+    now?: () => number;
+  } = {},
+) {
+  const output = deps.output ?? process.stdout;
+  const agent = args[0]?.trim();
+  if (!agent || agent === "--help" || agent === "-h") {
+    output.write("Usage: nolo agent usage qoder [--qoder-home <path>] [--stale-threshold-seconds <n>]\n");
+    return agent ? 0 : 1;
+  }
+  if (agent.toLowerCase() !== "qoder") {
+    output.write(`[nolo] agent usage currently supports qoder only, received ${agent}.\n`);
+    return 1;
+  }
+  const qoderHome =
+    readOption(args, "--qoder-home") ||
+    deps.env?.QODER_HOME ||
+    join(homedir(), ".qoder");
+  const now = deps.now ? deps.now() : Date.now();
+  const thresholdArg = readOption(args, "--stale-threshold-seconds");
+  const staleThresholdSeconds = thresholdArg ? Number(thresholdArg) : DEFAULT_STALE_THRESHOLD_SECONDS;
+  const usage = findLatestQoderQuotaUsage({ qoderHome, now });
+  const freshness = classifyQoderUsageFreshness(usage, { now, staleThresholdSeconds });
+  const ageSeconds = usage?.capturedAtMs != null ? Math.max(0, Math.floor((now - usage.capturedAtMs) / 1000)) : null;
+
+  if (!usage) {
+    const result: QoderUsageProbeResult = {
+      ok: false,
+      provider: "qoder",
+      freshness,
+      ageSeconds,
+      staleThresholdSeconds,
+      limitations: [
+        "This probe only reads Qoder package Credits from local quota logs.",
+        "It does not currently read the Qwen3.7-Max daily free request quota; check Qoder's Usage Overview or CLI /usage for that counter.",
+      ],
+      error:
+        "No Qoder quota usage log found. Open `qoder`, run `/usage`, then retry this command.",
+      reason:
+        "Probe could not locate any real [qoderApi] quota response line in local run logs.",
+    };
+    output.write(JSON.stringify(result, null, 2));
+    output.write("\n");
+    return 1;
+  }
+
+  const result: QoderUsageProbeResult = {
+    ok: true,
+    provider: "qoder",
+    usage,
+    limitations: [
+      "This is package Credits usage only, parsed from Qoder's /api/v2/quota/usage log.",
+      "Qwen3.7-Max daily free requests are a separate counter and are not exposed in this probe's current log source.",
+    ],
+    freshness,
+    ageSeconds,
+    staleThresholdSeconds,
+  };
+  if (freshness !== "fresh") {
+    result.reason =
+      freshness === "stale"
+        ? `Latest local quota log is ${ageSeconds}s old (threshold ${staleThresholdSeconds}s); UI or server may show a different value.`
+        : "Latest local quota log has no reliable capture timestamp; treat numbers as uncertain.";
+  }
+  output.write(JSON.stringify(result, null, 2));
+  output.write("\n");
+  return freshness === "fresh" ? 0 : 2;
+}

package/cli/scriptCommandEntries.ts

@@ -2,15 +2,12 @@ import { createScriptCommand, type CommandEntry } from "./cliCommandTypes";
 
 function getDocScriptCommands(): CommandEntry[] {
   return [
-    createScriptCommand(["doc", "create"], "createDoc.ts", "Create a normal doc"),
     createScriptCommand(["doc", "read"], "readDoc.ts", "Read a normal doc"),
     createScriptCommand(["doc", "update"], "updateDoc.ts", "Update a normal doc"),
     createScriptCommand(["doc", "delete"], "deleteDoc.ts", "Delete a normal doc"),
-    createScriptCommand(["skill-doc", "create"], "createSkillDoc.ts", "Create a skill doc"),
     createScriptCommand(["skill-doc", "read"], "readSkillDoc.ts", "Read a skill doc"),
     createScriptCommand(["skill-doc", "update"], "updateSkillDoc.ts", "Update a skill doc"),
     createScriptCommand(["skill-doc", "delete"], "deleteSkillDoc.ts", "Delete a skill doc"),
-    createScriptCommand(["skill", "create-doc"], "createSkillDoc.ts", "Create a skill-backed doc"),
   ];
 }
 

package/cli/secretScan.ts

@@ -0,0 +1,31 @@
+export type SecretFinding = {
+  label: string;
+  line: number;
+  preview: string;
+};
+
+const SECRET_PATTERNS: Array<{ label: string; pattern: RegExp }> = [
+  { label: "password", pattern: /\bpassword\s*[:=]\s*["']?[^"',\s#]{8,}/i },
+  { label: "psk", pattern: /\bpsk\s*[:=]\s*["']?[^"',\s#]{8,}/i },
+  { label: "api key", pattern: /\b(api[_-]?key|apikey)\s*[:=]\s*["']?[^"',\s#]{12,}/i },
+  { label: "token", pattern: /\b(token|secret)\s*[:=]\s*["']?[^"',\s#]{12,}/i },
+  { label: "private key", pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----/ },
+];
+
+export function findPotentialSecrets(text: string): SecretFinding[] {
+  return text
+    .split(/\r?\n/)
+    .flatMap((line, index) =>
+      SECRET_PATTERNS.filter(({ pattern }) => pattern.test(line)).map(({ label }) => ({
+        label,
+        line: index + 1,
+        preview: line.length > 120 ? `${line.slice(0, 117)}...` : line,
+      }))
+    );
+}
+
+export function formatSecretFindings(findings: SecretFinding[]) {
+  return findings
+    .map((finding) => `  line ${finding.line} (${finding.label}): ${finding.preview}`)
+    .join("\n");
+}

package/cli/tableCommands.ts

@@ -55,6 +55,11 @@ function parseOutputMode(raw: string): OutputMode {
   throw new Error(`--output must be one of full, raw, items, json, jsonl; got ${raw}`);
 }
 
+function resolveQueryColumns(columns: string[] | undefined, includeActivity: boolean): string[] | undefined {
+  if (!includeActivity) return columns;
+  return Array.isArray(columns) ? includeTableActivityColumns(columns) : undefined;
+}
+
 function parseTableArg(raw: string): { tenantId?: string; tableId?: string } {
   const trimmed = raw.trim();
   if (!trimmed) return {};
@@ -66,6 +71,32 @@ function parseTableArg(raw: string): { tenantId?: string; tableId?: string } {
   };
 }
 
+function normalizeSpaceInput(raw: string): string {
+  const value = raw.trim();
+  if (!value) return "";
+  if (value.startsWith("http://") || value.startsWith("https://")) {
+    const match = new URL(value).pathname.match(/^\/space\/([^/]+)/);
+    return match?.[1] ? decodeURIComponent(match[1]).replace(/^space-/, "") : "";
+  }
+  return value.replace(/^space-/, "");
+}
+
+function getSpaceContentKeys(spaceRecord: any): Set<string> {
+  const keys = new Set<string>();
+  const contents = spaceRecord?.contents;
+  if (!contents || typeof contents !== "object") return keys;
+  for (const [entryKey, value] of Object.entries(contents)) {
+    keys.add(entryKey);
+    if (value && typeof value === "object") {
+      const contentKey = (value as any).contentKey;
+      if (typeof contentKey === "string" && contentKey.trim()) {
+        keys.add(contentKey.trim());
+      }
+    }
+  }
+  return keys;
+}
+
 function resolveServerUrl(args: string[], env: EnvLike): string {
   return (
     readOption(args, "--server-url") ||
@@ -89,16 +120,46 @@ function resolveAuthToken(args: string[], env: EnvLike): string {
 }
 
 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;
+  for (const parsed of parseJwtPayloadCandidates(token)) {
+    const userId = parsed.userId;
+    const sub = parsed.sub;
+    if (typeof userId === "string" && userId) return userId;
+    if (typeof sub === "string" && sub) return sub;
   }
+  return undefined;
+}
+
+function parseJwtUsername(token: string): string | undefined {
+  for (const parsed of parseJwtPayloadCandidates(token)) {
+    const username = parsed.username;
+    if (typeof username === "string" && username.trim()) return username.trim();
+  }
+  return undefined;
+}
+
+function parseJwtPayloadCandidates(token: string): Array<Record<string, unknown>> {
+  const trimmed = token.trim();
+  if (!trimmed) return [];
+  const parts = trimmed.split(".").filter(Boolean);
+  const payloadCandidates = parts.length >= 3 ? [parts[1], parts[0]] : [parts[0]];
+  const parsed: Array<Record<string, unknown>> = [];
+  for (const payload of payloadCandidates) {
+    try {
+      const decoded = Buffer.from(payload, "base64").toString("utf8");
+      const value = JSON.parse(decoded);
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        parsed.push(value as Record<string, unknown>);
+      }
+    } catch {}
+  }
+  return parsed;
+}
+
+function resolveUserId(args: string[], env: EnvLike, authToken: string): string | undefined {
+  const explicit = readOption(args, "--tenant-id") || env.USER_ID || parseJwtTenantId(authToken);
+  if (explicit) return explicit;
+  const username = parseJwtUsername(authToken);
+  return username && /^[a-z0-9_-]+$/i.test(username) ? username : undefined;
 }
 
 function formatOutput(input: { envelope: any; rawData: any; mode: OutputMode }): string {
@@ -133,6 +194,182 @@ function usage(): string {
   ].join("\n");
 }
 
+function listUsage(): string {
+  return [
+    "Usage:",
+    "  nolo table list [--limit <n>] [--title-query <text>] [--purpose <purpose>] [--output full|raw|items|json|jsonl]",
+    "",
+  ].join("\n");
+}
+
+function tableHasPurpose(table: any, purpose: string): boolean {
+  return typeof table?.purpose === "string" && table.purpose.toLowerCase() === purpose.toLowerCase();
+}
+
+function getComparableUpdatedAt(record: any): number {
+  const raw = record?.updatedAt ?? record?.updated_at ?? record?.createdAt ?? record?.created;
+  if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+  if (typeof raw === "string") return Date.parse(raw) || 0;
+  return 0;
+}
+
+function formatTableListOutput(args: {
+  mode: OutputMode;
+  tables: any[];
+  envelope: any;
+}) {
+  if (args.mode === "full") return JSON.stringify(args.envelope, null, 2);
+  if (args.mode === "raw") return JSON.stringify(args.tables, null, 2);
+  if (args.mode === "items") return JSON.stringify(args.tables, null, 2);
+  return args.tables.map((item) => JSON.stringify(item)).join("\n");
+}
+
+export async function runTableListCommand(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(listUsage());
+    return 0;
+  }
+
+  let outputMode: OutputMode;
+  try {
+    outputMode = parseOutputMode(readOption(args, "--output") || "items");
+  } catch (error) {
+    output.write(`[nolo] table list failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+
+  const authToken = resolveAuthToken(args, env);
+  const userId = resolveUserId(args, env, authToken);
+  if (!userId) {
+    output.write("[nolo] table list failed: user id is required. Pass --tenant-id or use a login token.\n");
+    return 1;
+  }
+  if (!authToken) {
+    output.write("[nolo] table list failed: AUTH_TOKEN is required.\n");
+    return 1;
+  }
+
+  const limit = Math.max(1, Math.min(Number(readOption(args, "--limit") || 50), 200));
+  const titleQuery = readOption(args, "--title-query").trim().toLowerCase();
+  const purpose = readOption(args, "--purpose").trim();
+  const spaceId = normalizeSpaceInput(readOption(args, "--space") || readOption(args, "--space-id"));
+  const scanLimit = titleQuery || purpose ? Math.max(limit * 5, 200) : limit;
+  const serverUrl = resolveServerUrl(args, env);
+
+  let records: any[];
+  try {
+    records = spaceId
+      ? await fetchSpaceTableRecords({
+          authToken,
+          fetchImpl,
+          serverUrl,
+          spaceId,
+        })
+      : await fetchUserTableRecords({
+          authToken,
+          fetchImpl,
+          limit: Math.min(scanLimit, 500),
+          serverUrl,
+          userId,
+        });
+  } catch (error) {
+    output.write(`[nolo] table list failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+  const tables = records
+    .filter((table: any) => table && typeof table === "object" && !table.deletedAt)
+    .filter((table: any) => !titleQuery || String(table.displayName ?? table.name ?? table.title ?? "").toLowerCase().includes(titleQuery))
+    .filter((table: any) => !purpose || tableHasPurpose(table, purpose))
+    .sort((left: any, right: any) => getComparableUpdatedAt(right) - getComparableUpdatedAt(left))
+    .slice(0, limit)
+    .map((table: any) => ({
+      dbKey: table.dbKey ?? null,
+      tableId: table.tableId ?? null,
+      displayName: table.displayName ?? table.name ?? table.title ?? "(untitled)",
+      spaceId: table.spaceId ?? null,
+      tenantId: table.tenantId ?? null,
+      columnCount: Array.isArray(table.columns) ? table.columns.length : 0,
+      createdAt: table.createdAt ?? null,
+      updatedAt: table.updatedAt ?? table.updated_at ?? null,
+    }));
+
+  const envelope = { success: true, userId, ...(spaceId ? { space: spaceId } : {}), total: tables.length, tables };
+  output.write(`${formatTableListOutput({ mode: outputMode, tables, envelope })}\n`);
+  return 0;
+}
+
+async function readJsonResponse(response: Response) {
+  const text = await response.text();
+  let payload: any;
+  try {
+    payload = text ? JSON.parse(text) : {};
+  } catch {
+    if (!response.ok) throw new Error(text || response.statusText);
+    return text;
+  }
+  if (!response.ok || payload?.error) {
+    throw new Error(payload?.error ?? response.statusText);
+  }
+  return payload;
+}
+
+async function fetchUserTableRecords(args: {
+  authToken: string;
+  fetchImpl: typeof fetch;
+  limit: number;
+  serverUrl: string;
+  userId: string;
+}) {
+  const response = await args.fetchImpl(
+    `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(args.userId)}?limit=${args.limit}`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${args.authToken}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ type: "table" }),
+    }
+  );
+  const payload = await readJsonResponse(response);
+  return Array.isArray(payload?.data?.data)
+    ? payload.data.data
+    : Array.isArray(payload?.data)
+      ? payload.data
+      : [];
+}
+
+async function fetchSpaceTableRecords(args: {
+  authToken: string;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+  spaceId: string;
+}) {
+  const readRecord = async (dbKey: string) => {
+    const response = await args.fetchImpl(
+      `${args.serverUrl}/api/v1/db/read/${encodeURIComponent(dbKey)}`,
+      { headers: { Authorization: `Bearer ${args.authToken}` } }
+    );
+    const payload = await readJsonResponse(response);
+    return payload?.data ?? payload;
+  };
+  const space = await readRecord(`space-${args.spaceId}`);
+  const tableKeys = [...getSpaceContentKeys(space)].filter((key) => key.startsWith("meta-"));
+  const records = await Promise.all(
+    tableKeys.map(async (key) => {
+      try {
+        return await readRecord(key);
+      } catch {
+        return null;
+      }
+    })
+  );
+  return records.filter(Boolean);
+}
+
 export async function runTableQueryCommand(args: string[], deps: TableCommandDeps = {}): Promise<number> {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
@@ -159,7 +396,7 @@ export async function runTableQueryCommand(args: string[], deps: TableCommandDep
 
   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 tenantId = readOption(args, "--tenant-id") || tableArg.tenantId || resolveUserId(args, env, authToken);
   const tableId = tableArg.tableId;
   const hasSingleRowShortcut = Boolean(readOption(args, "--row") || readOption(args, "--row-id") || readOption(args, "--row-dbkey"));
   if (!tenantId || !tableId) {
@@ -184,9 +421,7 @@ export async function runTableQueryCommand(args: string[], deps: TableCommandDep
         tenantId,
         tableId,
         filters: filters ?? {},
-        columns: hasFlag(args, "--include-activity")
-          ? includeTableActivityColumns(columns)
-          : columns,
+        columns: resolveQueryColumns(columns, hasFlag(args, "--include-activity")),
         includeBaseFields: !hasFlag(args, "--no-base-fields"),
         limit: Number(readOption(args, "--limit") || (hasSingleRowShortcut ? 1 : 20)),
         offset: Number(readOption(args, "--offset") || 0),

package/cli/workflowInternalCommandEntries.ts

@@ -1,11 +1,10 @@
 import { createEnvCommand } from "./cliCommandFactories";
 import type { CommandEntry } from "./cliCommandTypes";
-import { runTableQueryCommand } from "./tableCommands";
-import { runTaskRunCommand } from "./taskRunCommand";
+import { runTableListCommand, runTableQueryCommand } from "./tableCommands";
 
 export function getWorkflowInternalCommandEntries(): CommandEntry[] {
   return [
+    createEnvCommand(["table", "list"], "List table metadata", runTableListCommand),
     createEnvCommand(["table", "query"], "Query table rows", runTableQueryCommand),
-    createEnvCommand(["task-run"], "Update durable task-run state through the runner bridge", runTaskRunCommand),
   ];
 }