@bli-cockpit/cli 0.2.31 → 0.2.33

package/dist/adapters/raw-evidence-sanitize.js

@@ -1,4 +1,4 @@
-import { containsSecretLikeContent, redactSecretLikeContent, } from "@bli-cockpit/telemetry-core";
+import { containsSecretLikeContent, redactSecretLikeContent, scannedCleanRedactionMetadata, } from "@bli-cockpit/telemetry-core";
 import { sha256 } from "./raw-evidence-keys.js";
 import { describeError } from "../health-detail.js";
 /** BLI-3238: a crashed redactor has to say so; see the catch below. */
@@ -165,32 +165,6 @@ function lineEndingOf(segment) {
         return "\n";
     return "";
 }
-/**
- * The receipt for a file the scan cleared (BLI-3277).
- *
- * Same schema, same `mode` — the deterministic ruleset is what ran — with the
- * verdict `scanned_clean` and zero of everything else. The content fields are
- * the point: an evidence ref is only readable downstream when its redaction
- * record hashes the bytes that are actually in the bucket, and for a clean file
- * those are the original bytes, so both halves carry the same digest and size.
- */
-function scannedCleanRedactionMetadata(originalBytes) {
-    const digest = sha256(originalBytes);
-    return {
-        schema_version: "raw-evidence-redaction.v1",
-        status: "scanned_clean",
-        mode: "deterministic_text_replacement",
-        applied_by: ["local_collector"],
-        rule_counts: [],
-        secret_like_match_count: 0,
-        redacted_fields: [],
-        redacted_ranges: [],
-        original_content_hash_sha256: digest,
-        sanitized_content_hash_sha256: digest,
-        original_byte_size: originalBytes.byteLength,
-        sanitized_byte_size: originalBytes.byteLength,
-    };
-}
 function fallbackRedactionMetadata(options) {
     const fullContentRedacted = options.fullContentRedacted !== false;
     return {

package/dist/commands/jarvis.js

@@ -0,0 +1,143 @@
+/**
+ * Terminal adapter for the shared JARVIS conversation gateway.
+ *
+ * This file owns terminal input and output only. Identity comes from the
+ * existing paired device session, and every turn is executed by the dashboard
+ * through the same JARVIS runtime used by web chat and Slack.
+ */
+import { errorMessage, isInteractiveStdin, readLine, writeLine } from "./cli-io.js";
+import { getCollectorRuntimePaths, readLocalCollectorSessionFile, } from "../local-state.js";
+export async function runJarvis(command, io) {
+    const session = await loadPairedSession(command.homeDir);
+    const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    const oneShotPrompt = await resolveOneShotPrompt(command, io);
+    if (oneShotPrompt !== null) {
+        return sendOneTurn({ command, dashboardUrl, deviceToken: session.device_token }, oneShotPrompt, io);
+    }
+    if (command.json) {
+        throw new Error("cockpit jarvis --json needs --prompt, positional text, or piped stdin.");
+    }
+    writeLine(io.stdout, "JARVIS terminal chat. Type /exit to leave.");
+    while (true) {
+        const prompt = (await readLine(io, "you> ")).trim();
+        if (!prompt)
+            continue;
+        if (prompt === "/exit" || prompt === "/quit")
+            return 0;
+        const exitCode = await sendOneTurn({ command, dashboardUrl, deviceToken: session.device_token }, prompt, io);
+        if (exitCode !== 0)
+            return exitCode;
+    }
+}
+async function loadPairedSession(homeDir) {
+    const paths = getCollectorRuntimePaths(homeDir);
+    try {
+        const session = await readLocalCollectorSessionFile(paths);
+        if (session.session_state !== "valid") {
+            throw new Error(`session_${session.session_state}`);
+        }
+        return session;
+    }
+    catch (error) {
+        throw new Error(`JARVIS needs a valid paired Cockpit session. Run \`cockpit login\`, then try again (${errorMessage(error)}).`);
+    }
+}
+async function resolveOneShotPrompt(command, io) {
+    if (command.prompt)
+        return validatePrompt(command.prompt);
+    if (isInteractiveStdin(io))
+        return null;
+    const piped = await readAll(io.stdin);
+    return validatePrompt(piped);
+}
+async function sendOneTurn(context, prompt, io) {
+    const startedAt = Date.now();
+    let response;
+    try {
+        response = await io.fetch(`${context.dashboardUrl}/api/jarvis/cli`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${context.deviceToken}`,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                question: prompt,
+                thread: context.command.thread,
+                subject: context.command.subject,
+            }),
+        });
+    }
+    catch (error) {
+        writeFailure(context.command, io, "gateway_unreachable", errorMessage(error));
+        return 1;
+    }
+    const body = await readReply(response);
+    if (!response.ok || !body.ok || !body.reply) {
+        const reason = body.error ?? body.reply ?? `http_${response.status}`;
+        writeFailure(context.command, io, "turn_failed", reason);
+        return 1;
+    }
+    if (context.command.json) {
+        writeLine(io.stdout, JSON.stringify({
+            ok: true,
+            reply: body.reply,
+            thread: body.thread ?? context.command.thread,
+            model: body.model ?? null,
+            subject: body.subject ?? null,
+        }));
+    }
+    else {
+        const subject = body.subject?.displayName ? ` (${body.subject.displayName})` : "";
+        writeLine(io.stdout, `jarvis${subject}> ${body.reply}`);
+    }
+    writeLine(io.stderr, `[jarvis cli] answered ${JSON.stringify({
+        prompt_length: prompt.length,
+        reply_length: body.reply.length,
+        elapsed_ms: Date.now() - startedAt,
+        thread: context.command.thread === "main" ? "default" : "named",
+        subject: context.command.subject ? "selected" : "caller",
+    })}`);
+    return 0;
+}
+async function readReply(response) {
+    const text = await response.text();
+    if (!text)
+        return { ok: false, error: "empty_response" };
+    try {
+        const value = JSON.parse(text);
+        if (!value || typeof value !== "object") {
+            return { ok: false, error: "response_body_not_object" };
+        }
+        return value;
+    }
+    catch {
+        return { ok: false, error: "response_body_not_json" };
+    }
+}
+function writeFailure(command, io, reason, detail) {
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: false, error: reason, detail }));
+        return;
+    }
+    writeLine(io.stderr, `JARVIS could not answer: ${detail}`);
+}
+function validatePrompt(raw) {
+    const prompt = raw.trim();
+    if (!prompt)
+        throw new Error("JARVIS needs a non-empty question.");
+    if (prompt.length > 4000) {
+        throw new Error("JARVIS questions are limited to 4000 characters.");
+    }
+    return prompt;
+}
+async function readAll(stream) {
+    stream.setEncoding("utf8");
+    let text = "";
+    for await (const chunk of stream) {
+        text += chunk;
+        if (text.length > 4000) {
+            throw new Error("JARVIS questions are limited to 4000 characters.");
+        }
+    }
+    return text;
+}

package/dist/commands/local-args.js

@@ -47,6 +47,8 @@ export function parseLocalArgs(argv) {
             return parseSyncArgs(argv.slice(1));
         case "analyze":
             return parseAnalyzeArgs(argv.slice(1));
+        case "jarvis":
+            return parseJarvisArgs(argv.slice(1));
         case "backfill":
             return parseBackfillArgs(argv.slice(1));
         case "status":
@@ -607,6 +609,30 @@ function parseAgentRulesHost(value) {
         return host;
     throw new Error("agent-rules --host must be codex, claude, or all.");
 }
+function parseJarvisArgs(args) {
+    const values = parseNamedArgs(args, {
+        allowedFlags: ["--home", "--dashboard-url", "--prompt", "--as", "--thread", "--json"],
+        valueFlags: ["--home", "--dashboard-url", "--prompt", "--as", "--thread"],
+    });
+    const flaggedPrompt = optionalNonEmpty(values.flags.get("--prompt"));
+    const positionalPrompt = optionalNonEmpty(values.positionals.join(" "));
+    if (flaggedPrompt && positionalPrompt) {
+        throw new Error("jarvis accepts either --prompt or positional text, not both.");
+    }
+    const thread = optionalNonEmpty(values.flags.get("--thread")) ?? "main";
+    if (!/^[A-Za-z0-9_-]{1,40}$/.test(thread)) {
+        throw new Error("jarvis --thread must use 1 to 40 letters, numbers, underscores, or hyphens.");
+    }
+    return {
+        kind: "jarvis",
+        homeDir: optionalNonEmpty(values.flags.get("--home")),
+        dashboardUrl: optionalUrl(values.flags.get("--dashboard-url")),
+        prompt: flaggedPrompt ?? positionalPrompt,
+        subject: optionalNonEmpty(values.flags.get("--as")),
+        thread,
+        json: values.booleans.has("--json"),
+    };
+}
 function parseNamedArgs(args, options) {
     const allowed = new Set(options.allowedFlags);
     const valueFlags = new Set(options.valueFlags);

package/dist/commands/local-help.js

@@ -21,6 +21,7 @@ export const rootCommandNames = new Set([
     "start",
     "sync",
     "analyze",
+    "jarvis",
     "backfill",
     "status",
     "sessions",
@@ -45,6 +46,7 @@ export function localCommandHelp(command) {
         "  cockpit start [--ticket <id>|--clear-ticket] [--topic <label>] [--intent <intent>] [--phase <phase>] [--workspace <path>] [--branch <name>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit sync [--workspace <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit analyze [--workspace <path>] [--dashboard-url <url>] [--max-depth <n>] [--max-repos <n>] [--json]",
+        "  cockpit jarvis [question] [--prompt <question>] [--as <person>] [--thread <name>] [--dashboard-url <url>] [--json]",
         "  cockpit backfill (--since-days <n>|--all) [--source codex|claude] [--dry-run] [--max-files <n>] [--max-depth <n>] [--max-repos <n>] [--yes] [--workspace <path>] [--json]",
         "  cockpit status [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit sessions [--source codex|claude] [--since-days <n>|--all] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
@@ -185,6 +187,20 @@ function localSubcommandHelp(command) {
                 "`--repo <path>` remains supported as a backward-compatible alias.",
             ],
         ],
+        [
+            "jarvis",
+            [
+                "Usage: cockpit jarvis [question] [--prompt <question>] [--as <person>] [--thread <name>] [--dashboard-url <url>] [--json]",
+                "",
+                "Chats with the same JARVIS used by Cockpit web chat and the BLI Slack DM.",
+                "--as selects the existing website person space; it changes who the chat is about, never who is authenticated.",
+                "Run with no question for an interactive terminal conversation.",
+                "Agents can pass --prompt, positional text, or pipe one question on stdin.",
+                "--json writes one machine-readable response to stdout; operational metadata stays on stderr.",
+                "The command uses the existing paired device identity. It cannot override the caller, team, role, or person scope.",
+                "Run `cockpit login` first if this machine is not paired.",
+            ],
+        ],
         [
             "backfill",
             [

package/dist/commands/local.js

@@ -16,6 +16,7 @@
  *   install-update.ts    install, update, self-update, release
  *   status.ts            `cockpit status`
  *   sessions.ts          `cockpit sessions`
+ *   jarvis.ts            terminal adapter for the shared JARVIS gateway
  *
  * What stays here is orchestration: onboard, login/logout/start, the sync tick,
  * analyze, serve, autostart and agent-rules.
@@ -32,6 +33,7 @@ import { attributedSyncRunStatus, cursorStatusLine, displayTicketId, rawEvidence
 import { runInstall, runRelease, runSelfUpdate, runUpdate, SelfUpdateError, } from "./install-update.js";
 import { runStatus } from "./status.js";
 import { runSessions } from "./sessions.js";
+import { runJarvis } from "./jarvis.js";
 import { createCollectorServer } from "../server.js";
 import { inspectAgentRules, installAgentRules, uninstallAgentRules, } from "../agent-rules.js";
 import { backfillRetryCommand, runBackfill, runBackfillCommand, } from "./backfill.js";
@@ -98,6 +100,8 @@ export async function runLocalCockpitCli(argv, io = defaultIo()) {
                 return await runSync(command, io);
             case "analyze":
                 return await runAnalyze(command, io);
+            case "jarvis":
+                return await runJarvis(command, io);
             case "backfill":
                 return await runBackfillCommand(command, io);
             case "status":

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.31");
+    writeLine(io?.stdout ?? process.stdout, "0.2.33");
     return 0;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.31",
+  "version": "0.2.33",
   "private": false,
   "type": "module",
   "bin": {
@@ -26,6 +26,6 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/telemetry-core": "0.1.23"
+    "@bli-cockpit/telemetry-core": "0.1.24"
   }
 }