@illuminis/comprism 0.1.2 → 0.1.4

package/out/commands/plugins.js

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGINS_HELP = void 0;
+exports.readFolder = readFolder;
+exports.cmdPlugins = cmdPlugins;
+/**
+ * `comprism plugins` (manual 9.15 to 9.17): install from a folder or the
+ * company's catalog, then enable, disable, update and remove.
+ *
+ * Installing reads the folder's text files and sends them; nothing in the
+ * folder is ever run. The service decides what a plugin adds, who it is for,
+ * whether the company allows it, and every word shown.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const gateway_1 = require("../lib/gateway");
+const project_1 = require("../lib/project");
+const ui = __importStar(require("../lib/ui"));
+const out = (s = "") => process.stdout.write(`${s}\n`);
+const MAX_FILES = 200;
+const MAX_BYTES = 50_000;
+const SKIP = new Set([".git", "node_modules", ".DS_Store"]);
+/** Every text file in the folder, by path inside it. Never runs anything. */
+function readFolder(dir) {
+    const files = {};
+    const walk = (at, rel) => {
+        for (const e of fs.readdirSync(at, { withFileTypes: true })) {
+            if (Object.keys(files).length >= MAX_FILES || SKIP.has(e.name))
+                continue;
+            const full = path.join(at, e.name);
+            const inside = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+                walk(full, inside);
+                continue;
+            }
+            if (!e.isFile() || fs.statSync(full).size > MAX_BYTES)
+                continue;
+            const text = fs.readFileSync(full, "utf8");
+            if (!text.includes("\u0000"))
+                files[inside] = text;
+        }
+    };
+    walk(dir, "");
+    return files;
+}
+async function call(payload) {
+    const reply = await (0, gateway_1.ask)({ intent: "plugins", prompt: "", pluginsPayload: payload });
+    const body = reply.plugins;
+    if (!reply.ok || reply.served === false || !body) {
+        out(`  ${ui.fail(reply.message || "Your plugins could not be read from your workspace.")}`);
+        return null;
+    }
+    if (body.error) {
+        out(`  ${ui.fail(body.error)}`);
+        return null;
+    }
+    return body;
+}
+function question(prompt) {
+    if (!process.stdin.isTTY && process.stdin.readableEnded)
+        return Promise.resolve("");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => rl.question(prompt, (a) => { rl.close(); resolve(a.trim()); }));
+}
+exports.PLUGINS_HELP = `  comprism plugins                       installed plugins and their state
+  comprism plugins install <name|folder> install from your company's catalog or a folder
+      --scope project|personal           skip the question
+  comprism plugins enable <name>         comprism plugins disable <name>
+  comprism plugins update <name>         shows what changes, then asks
+  comprism plugins remove <name>`;
+async function cmdPlugins(args) {
+    if (args.includes("--help") || args.includes("-h")) {
+        out(exports.PLUGINS_HELP);
+        return 0;
+    }
+    const valued = new Set(["--scope", "--cwd"]);
+    const [sub, target] = args.filter((a, i) => !a.startsWith("--") && !valued.has(args[i - 1] ?? ""));
+    const at = args.indexOf("--cwd");
+    const root = (0, project_1.resolveProject)(at >= 0 && args[at + 1] ? String(args[at + 1]) : process.cwd()).root;
+    const base = { project: root };
+    const yes = args.includes("--yes");
+    if (!sub) {
+        const body = await call({ ...base, op: "list" });
+        if (!body)
+            return 1;
+        for (const l of body.lines ?? [])
+            out(`  ${l}`);
+        return 0;
+    }
+    if (!target) {
+        out(`  ${ui.fail(`comprism plugins ${sub} takes a plugin${sub === "install" ? " name or folder" : " name"}.`)}`);
+        return 2;
+    }
+    if (sub === "install") {
+        const folder = path.resolve(target);
+        const fromFolder = fs.existsSync(folder) && fs.statSync(folder).isDirectory();
+        const source = fromFolder ? { files: readFolder(folder), folder } : { name: target };
+        const preview = await call({ ...base, ...source, op: "preview" });
+        if (!preview)
+            return 1;
+        for (const l of preview.lines ?? [])
+            out(`  ${l}`);
+        let scope = args.indexOf("--scope") >= 0 ? args[args.indexOf("--scope") + 1] : undefined;
+        if (!scope) {
+            const said = await question(`  Install for: 1 this project  2 just me  3 cancel  `);
+            scope = said === "1" ? "project" : said === "2" ? "personal" : undefined;
+            if (!scope) {
+                out("  Nothing was installed.");
+                return 0;
+            }
+        }
+        const done = await call({ ...base, ...source, op: "install", scope });
+        if (!done)
+            return 1;
+        out(`  ${done.line ?? ""}`);
+        return 0;
+    }
+    if (sub === "update") {
+        let preview = await call({ ...base, op: "update_preview", name: target });
+        let files;
+        if (preview?.folder) {
+            if (!fs.existsSync(preview.folder)) {
+                out(`  ${ui.fail(`${target} was installed from ${preview.folder}, which is not on this machine.`)}`);
+                return 1;
+            }
+            files = readFolder(preview.folder);
+            preview = await call({ ...base, op: "update_preview", name: target, files });
+        }
+        if (!preview)
+            return 1;
+        for (const l of preview.lines ?? [])
+            out(`  ${l}`);
+        if (preview.same) {
+            out(`  ${target} is already up to date.`);
+            return 0;
+        }
+        const go = yes || /^y(es)?$/i.test(await question("  Apply this update? [y/N] "));
+        if (!go) {
+            out("  Nothing was changed.");
+            return 0;
+        }
+        const done = await call({ ...base, op: "update", name: target, ...(files ? { files } : {}) });
+        if (!done)
+            return 1;
+        out(`  ${done.line ?? ""}`);
+        return 0;
+    }
+    if (["enable", "disable", "remove"].includes(sub)) {
+        const done = await call({ ...base, op: sub, name: target });
+        if (!done)
+            return 1;
+        out(`  ${done.line ?? ""}`);
+        return 0;
+    }
+    out(`  ${ui.fail(`\`plugins ${sub}\` is not a plugins command.`)}`);
+    out(exports.PLUGINS_HELP);
+    return 2;
+}

package/out/commands/privacy.d.ts

@@ -0,0 +1 @@
+export declare function cmdPrivacy(): Promise<number>;

package/out/commands/privacy.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cmdPrivacy = cmdPrivacy;
+/**
+ * `comprism privacy` (manual 2.13): what your company keeps about your work,
+ * exactly as the service and the portal state it.
+ */
+const gateway_1 = require("../lib/gateway");
+const ui = __importStar(require("../lib/ui"));
+const out = (s = "") => process.stdout.write(s + "\n");
+async function cmdPrivacy() {
+    const reply = await (0, gateway_1.ask)({ intent: "privacy", prompt: "" });
+    if (!reply.ok || reply.served === false) {
+        out(ui.fail(reply.served === false
+            ? "Your workspace is running an older build that does not answer this yet."
+            : `Your workspace could not be reached: ${reply.message || "no answer"}`));
+        return 1;
+    }
+    out();
+    for (const line of reply.lines ?? [])
+        out(line);
+    out();
+    return 0;
+}

package/out/commands/providerKey.d.ts

@@ -0,0 +1,32 @@
+export interface RemoteKeyStatus {
+    is_set: boolean;
+    last_four: string | null;
+    updated_at: string | null;
+    effective_source: 'tenant' | 'shared' | null;
+    is_base_tenant: boolean;
+    request_header: string;
+}
+export interface Target {
+    url: string;
+    token: string;
+    tenant?: string;
+}
+/** The tenant we are signed in to, or null with the reason left to the caller. */
+export declare function target(overrides?: Partial<Target>): Target | null;
+export declare function remoteStatus(t: Target): Promise<RemoteKeyStatus>;
+/** Send the key this machine already resolves, for the connector surface. */
+export declare function push(t: Target, value: string): Promise<RemoteKeyStatus>;
+export declare function clear(t: Target): Promise<RemoteKeyStatus>;
+/**
+ * The Anthropic key this machine would use, and where it came from.
+ *
+ * Deliberately the same resolution the recorder and the proxy use rather than a
+ * second reading of the environment: a `key push` that sent something other
+ * than the key this machine actually works with would be worse than useless,
+ * because the person would have proved the wrong secret.
+ */
+export declare function localKey(): {
+    value: string | null;
+    from: 'env' | 'command' | 'none';
+};
+export declare function localKeyHint(): string;

package/out/commands/providerKey.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.target = target;
+exports.remoteStatus = remoteStatus;
+exports.push = push;
+exports.clear = clear;
+exports.localKey = localKey;
+exports.localKeyHint = localKeyHint;
+/**
+ * The tenant's stored Anthropic key, from this machine.
+ *
+ * ── Why a command exists for something we would rather not do ─────────────
+ *
+ * This product's default is that a provider key never leaves the machine it
+ * lives on: `config.ts` resolves it from the environment or a key command at
+ * the moment of use, writes it to no file, and the proxy forwards the caller's
+ * own credential without reading it. Nothing in the terminal or IDE path needs
+ * a key held anywhere else, and that is the path most people are on.
+ *
+ * One surface cannot work that way. An MCP connector - Claude Desktop,
+ * claude.ai - reaches the tenant through a protocol with no channel for a
+ * provider credential, so the server has to hold one to answer those prompts at
+ * all. The alternative was the server quietly answering them on illuminis's
+ * key, which is worse for the customer in every direction: an invoice they
+ * cannot audit, a saving measured on somebody else's account, and no way to
+ * turn it off.
+ *
+ * So the key can be pushed, deliberately, by a person typing a verb that says
+ * what it does. Three properties hold either way:
+ *
+ *   - it still is not written to any file on this machine;
+ *   - it travels once, over TLS, to the tenant that person is signed in to;
+ *   - `comprism key clear` takes it back out, and after that the connector
+ *     refuses rather than falling back to anyone else's account.
+ */
+const config_1 = require("../lib/config");
+const connection_1 = require("../lib/connection");
+/** The tenant we are signed in to, or null with the reason left to the caller. */
+function target(overrides = {}) {
+    const stored = (0, connection_1.readConnection)();
+    const url = overrides.url || stored?.url;
+    const token = overrides.token || process.env.COMPRISM_TOKEN || stored?.token;
+    if (!url || !token)
+        return null;
+    const tenant = overrides.tenant || stored?.tenant;
+    return { url: url.replace(/\/+$/, ''), token, ...(tenant ? { tenant } : {}) };
+}
+function headers(t) {
+    const h = {
+        'content-type': 'application/json',
+        authorization: `Bearer ${t.token}`,
+    };
+    // Only needed on localhost, where there is no subdomain to resolve the tenant
+    // from. Hyphenated, because that is the tenant NAME - the schema is spelled
+    // with an underscore and mixing the two is this codebase's classic bug.
+    if (t.tenant)
+        h['X-Tenant-ID'] = t.tenant;
+    return h;
+}
+async function call(t, method, body) {
+    const res = await fetch(`${t.url}/api/v1/completion/provider-key`, {
+        method,
+        headers: headers(t),
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+    if (!res.ok) {
+        // The detail, where the API gave one - it carries the remedy. Never the
+        // whole body blind: an error body on a credential route can echo input.
+        let detail = `${res.status} ${res.statusText}`;
+        try {
+            const parsed = (await res.json());
+            if (parsed?.detail)
+                detail = parsed.detail;
+        }
+        catch {
+            /* a body we cannot parse tells us nothing worth saying */
+        }
+        throw new Error(detail);
+    }
+    return (await res.json());
+}
+function remoteStatus(t) {
+    return call(t, 'GET');
+}
+/** Send the key this machine already resolves, for the connector surface. */
+function push(t, value) {
+    return call(t, 'PUT', { value });
+}
+function clear(t) {
+    return call(t, 'DELETE');
+}
+/**
+ * The Anthropic key this machine would use, and where it came from.
+ *
+ * Deliberately the same resolution the recorder and the proxy use rather than a
+ * second reading of the environment: a `key push` that sent something other
+ * than the key this machine actually works with would be worse than useless,
+ * because the person would have proved the wrong secret.
+ */
+function localKey() {
+    const cfg = (0, config_1.loadConfig)();
+    const from = (0, config_1.keySource)(cfg, 'anthropic');
+    const value = (0, config_1.resolveKeys)(cfg).anthropic || null;
+    return { value, from };
+}
+function localKeyHint() {
+    return `set ${(0, config_1.envVarName)('anthropic')}, or configure a key command in config.json`;
+}

package/out/commands/repl.d.ts

@@ -1 +1,8 @@
-export declare function runRepl(): Promise<void>;
+/** How a session is opened: fresh, the latest in this project, a named one,
+ *  or chosen from the list (manual 8.4, 8.5). */
+export interface Opening {
+    latest?: boolean;
+    resume?: string;
+    pick?: boolean;
+}
+export declare function runRepl(how?: Opening): Promise<void>;