nolo-cli 0.1.40 → 0.1.42

package/cli/memoryCommands.ts

@@ -0,0 +1,253 @@
+import type { AgentCommandDeps } from "./agentCommandSupport";
+import {
+  readOption,
+  resolveAuthToken,
+  resolveServerCandidates,
+  resolveServerUrl,
+} from "./cliEnvHelpers";
+
+const VALUE_FLAGS = new Set([
+  "--facet",
+  "--id",
+  "--ids",
+  "--kind",
+  "--limit",
+  "--pattern-prefix",
+  "--server",
+  "--server-url",
+  "--source-dialog",
+  "--subject",
+  "--subject-id",
+  "--subject-type",
+  "--tag",
+  "--token",
+]);
+
+function hasFlag(args: string[], flag: string) {
+  return args.includes(flag);
+}
+
+function printMemoryDeleteUsage(output: { write(chunk: string): unknown }) {
+  output.write(`Usage:
+  nolo memory delete --source-dialog <dialogId> --yes [--json]
+  nolo memory delete --tag <tag> --kind <kind> --yes
+  nolo memory delete --pattern-prefix <prefix> --limit <n> --yes
+
+Options:
+  --id <memoryId>            Delete a specific memory id. Repeatable.
+  --ids <a,b,c>              Delete specific memory ids.
+  --source-dialog <dialogId> Delete memories created from one dialog.
+  --tag <tag>                Require a tag. Repeatable.
+  --kind <kind>              Filter episodic / semantic / procedural. Repeatable.
+  --facet <facet>            Filter preference / tension / unfinished / goal / style. Repeatable.
+  --subject-type <type>      Filter user / agent / space / project / system.
+  --subject <subjectId>      Filter subjectId.
+  --pattern-prefix <prefix>  Filter patternKey prefix.
+  --limit <n>                Maximum memories to delete.
+  --yes                      Actually delete. Without this, command is a dry-run.
+  --json                     Print machine-readable JSON.
+  --server <url>             Prefer this server and include known Nolo peers.
+  --token <jwt>              Override AUTH_TOKEN.
+
+At least one filter is required; this command will not delete all memory implicitly.
+`);
+}
+
+function readRepeated(args: string[], flag: string) {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] !== flag) continue;
+    const value = args[index + 1];
+    if (typeof value === "string" && value.trim()) values.push(value.trim());
+  }
+  return values;
+}
+
+function readCsvValues(args: string[], flag: string) {
+  const raw = readRepeated(args, flag).join(",");
+  return raw
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+function readLimit(args: string[]) {
+  const raw = readOption(args, "--limit");
+  if (!raw) return undefined;
+  if (!/^\d+$/.test(raw)) throw new Error(`invalid --limit: ${raw}`);
+  const parsed = Number(raw);
+  return parsed > 0 ? parsed : undefined;
+}
+
+function assertNoUnknownFlags(args: string[]) {
+  for (let index = 0; index < args.length; index += 1) {
+    const value = args[index];
+    if (!value.startsWith("-")) continue;
+    if (value === "--help" || value === "-h" || value === "--yes" || value === "--json") continue;
+    if (VALUE_FLAGS.has(value)) {
+      index += 1;
+      continue;
+    }
+    throw new Error(`unknown option: ${value}`);
+  }
+}
+
+function buildDeleteBody(args: string[]) {
+  const ids = [...readRepeated(args, "--id"), ...readCsvValues(args, "--ids")];
+  const kinds = readRepeated(args, "--kind");
+  const facets = readRepeated(args, "--facet");
+  const tags = readRepeated(args, "--tag");
+  const sourceDialogId = readOption(args, "--source-dialog")?.trim();
+  const subjectType = readOption(args, "--subject-type")?.trim();
+  const subjectId = (readOption(args, "--subject") ?? readOption(args, "--subject-id"))?.trim();
+  const patternKeyPrefix = readOption(args, "--pattern-prefix")?.trim();
+  const limit = readLimit(args);
+
+  const body: Record<string, unknown> = {};
+  if (ids.length) body.ids = [...new Set(ids)];
+  if (kinds.length) body.kinds = [...new Set(kinds)];
+  if (facets.length) body.facets = [...new Set(facets)];
+  if (tags.length) body.tags = [...new Set(tags)];
+  if (sourceDialogId) body.sourceDialogId = sourceDialogId;
+  if (subjectType) body.subjectType = subjectType;
+  if (subjectId) body.subjectId = subjectId;
+  if (patternKeyPrefix) body.patternKeyPrefix = patternKeyPrefix;
+  if (typeof limit === "number") body.limit = limit;
+  return body;
+}
+
+function hasDeleteFilter(body: Record<string, unknown>) {
+  return Object.keys(body).some((key) => key !== "limit");
+}
+
+async function postMemoryDelete(args: {
+  authToken: string;
+  body: Record<string, unknown>;
+  fetchImpl: typeof fetch;
+  serverUrl: string;
+}) {
+  const res = await args.fetchImpl(`${args.serverUrl}/api/memory/delete`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${args.authToken}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(args.body),
+  });
+  const text = await res.text();
+  let payload: any = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = { raw: text };
+  }
+  if (!res.ok || payload?.error) {
+    const message =
+      payload?.error?.message ??
+      payload?.message ??
+      payload?.error ??
+      `HTTP ${res.status}`;
+    throw new Error(`${message}`);
+  }
+  return payload;
+}
+
+export async function runMemoryDeleteCommand(
+  args: string[],
+  deps: AgentCommandDeps = {}
+) {
+  const env = deps.env ?? process.env;
+  const output = deps.output ?? process.stdout;
+  if (hasFlag(args, "--help") || hasFlag(args, "-h")) {
+    printMemoryDeleteUsage(output);
+    return 0;
+  }
+
+  try {
+    assertNoUnknownFlags(args);
+    const authToken = resolveAuthToken(args, env);
+    if (!authToken) {
+      output.write("[nolo] memory delete requires an auth token. Run `nolo login` or set AUTH_TOKEN.\n");
+      return 1;
+    }
+
+    const body = buildDeleteBody(args);
+    if (!hasDeleteFilter(body)) {
+      output.write("[nolo] memory delete requires at least one filter; use --help for examples.\n");
+      return 1;
+    }
+
+    const shouldDelete = hasFlag(args, "--yes");
+    const wantJson = hasFlag(args, "--json");
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const serverUrl = resolveServerUrl(args, env);
+    const serverUrls = resolveServerCandidates(args, env, serverUrl);
+
+    if (!shouldDelete) {
+      const payload = {
+        dryRun: true,
+        deleted: false,
+        targetServers: serverUrls,
+        request: body,
+        nextStep: "rerun with --yes to delete matching memories",
+      };
+      if (wantJson) {
+        output.write(`${JSON.stringify(payload, null, 2)}\n`);
+      } else {
+        output.write("dryRun: true\n");
+        output.write(`targetServers: ${serverUrls.join(", ")}\n`);
+        output.write(`request: ${JSON.stringify(body)}\n`);
+        output.write("rerun with --yes to delete matching memories\n");
+      }
+      return 0;
+    }
+
+    const deleteResults = [];
+    for (const target of serverUrls) {
+      try {
+        const result = await postMemoryDelete({
+          authToken,
+          body,
+          fetchImpl,
+          serverUrl: target,
+        });
+        deleteResults.push({ serverUrl: target, ok: true, result });
+      } catch (error) {
+        deleteResults.push({
+          serverUrl: target,
+          ok: false,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    const deletedCount = deleteResults.reduce(
+      (sum, item) => sum + (item.ok ? Number(item.result?.deletedCount ?? 0) : 0),
+      0
+    );
+    const payload = {
+      dryRun: false,
+      deleted: true,
+      deletedCount,
+      request: body,
+      targetServers: serverUrls,
+      deleteResults,
+    };
+    if (wantJson) {
+      output.write(`${JSON.stringify(payload, null, 2)}\n`);
+    } else {
+      output.write(`deletedCount: ${deletedCount}\n`);
+      for (const result of deleteResults) {
+        output.write(
+          result.ok
+            ? `${result.serverUrl}: ok deleted=${result.result?.deletedCount ?? 0}\n`
+            : `${result.serverUrl}: failed ${result.error}\n`
+        );
+      }
+    }
+    return deleteResults.some((result) => result.ok) ? 0 : 1;
+  } catch (error) {
+    output.write(`[nolo] memory delete failed: ${error instanceof Error ? error.message : String(error)}\n`);
+    return 1;
+  }
+}

package/cli/memoryInternalCommandEntries.ts

@@ -0,0 +1,9 @@
+import type { CommandEntry } from "./cliCommandTypes";
+import { createEnvCommand } from "./cliCommandFactories";
+import { runMemoryDeleteCommand } from "./memoryCommands";
+
+export function getMemoryInternalCommandEntries(): CommandEntry[] {
+  return [
+    createEnvCommand(["memory", "delete"], "Delete long-term memories by filter", runMemoryDeleteCommand),
+  ];
+}

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");
+}