@illuminis/comprism 0.1.0

package/out/lib/config.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOME_DIR_NAME = void 0;
+exports.homeDir = homeDir;
+exports.ensureHome = ensureHome;
+exports.configPath = configPath;
+exports.defaultConfig = defaultConfig;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.resolveKeys = resolveKeys;
+exports.availableProviders = availableProviders;
+exports.keySource = keySource;
+exports.envVarName = envVarName;
+/**
+ * Home directory, configuration and key resolution.
+ *
+ * ── Keys are never written. Anywhere. ──────────────────────────────────────
+ *
+ * The frozen spec (0.6) says keys resolve "from env first, then config file".
+ * This implementation keeps the first half and drops the second, deliberately,
+ * and it is a strengthening rather than a simplification: nothing about the
+ * mechanism changes, one storage location is removed.
+ *
+ * The reason is that Phase 1's acceptance list contains an absolute canary -
+ * "keys never appear in any file or log". A config file that may hold a key
+ * makes that test conditional on which file you look in, and a security
+ * property that holds in most files is not a security property. So:
+ *
+ *   1. `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` from the environment, or
+ *   2. a `keyCommand` the user configures - a shell command that PRINTS the key
+ *      (`op read ...`, `aws secretsmanager get-secret-value ...`). The command
+ *      is stored; its output never is.
+ *
+ * That covers the case the config-file fallback existed for - a user who does
+ * not want long-lived secrets in their shell profile - without the Companion
+ * ever holding a secret at rest.
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.HOME_DIR_NAME = '.comprism';
+function homeDir() {
+    return process.env.COMPRISM_HOME || node_path_1.default.join(node_os_1.default.homedir(), exports.HOME_DIR_NAME);
+}
+/**
+ * Create the home directory at mode 700 if it is not there.
+ *
+ * 700 rather than the default 755: other local accounts have no business
+ * reading someone's work records, and a directory created world-readable is
+ * never noticed afterwards.
+ */
+function ensureHome() {
+    const dir = homeDir();
+    node_fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        node_fs_1.default.chmodSync(dir, 0o700);
+    }
+    catch {
+        /* a filesystem that cannot chmod is not a reason to fail a request */
+    }
+    return dir;
+}
+function configPath() {
+    return node_path_1.default.join(homeDir(), 'config.json');
+}
+function defaultConfig() {
+    const now = new Date().toISOString();
+    return {
+        config_version: 1,
+        user: node_os_1.default.userInfo().username,
+        mode: 'monitor',
+        providers: {
+            anthropic: { enabled: true },
+            openai: { enabled: true },
+        },
+        allowedModels: [],
+        // Balanced and capable. The band is still recorded on every decision; it
+        // simply does not drive dispatch while the estimator has nothing to say.
+        defaultModel: 'claude-sonnet-5',
+        // ON by default, and the customer turns it off. Their work lives on our
+        // servers exactly as their other business data lives on a vendor's, and a
+        // product that cannot see the work cannot show them what finishing it cost
+        // or improve at predicting it. Opting out is one setting on their account,
+        // not a request they have to make of us.
+        contentPolicy: { storeText: true },
+        context: {},
+        proxyPort: 8787,
+        footer: {
+            enabled: true,
+            template: 'completion',
+            // `auto` is the next capability band up on the same provider - the
+            // comparison a person actually makes. A tenant that has mandated one
+            // model everywhere names it here instead.
+            baselineModel: 'auto',
+            tenant: '',
+            // Production by default. Localhost is opt-in for development via
+            // COMPRISM_DEV=1, so a fresh install talks to the real tenant and a
+            // receipt's link goes somewhere a person can actually open.
+            portal: {
+                useDev: process.env.COMPRISM_DEV === '1',
+                devUrl: 'http://localhost:5182',
+                domain: 'completionprism.illuminis.ai',
+            },
+            pricing: {},
+        },
+        created: now,
+        updated: now,
+    };
+}
+function loadConfig() {
+    const p = configPath();
+    if (!node_fs_1.default.existsSync(p))
+        return defaultConfig();
+    try {
+        const raw = JSON.parse(node_fs_1.default.readFileSync(p, 'utf8'));
+        const base = defaultConfig();
+        return {
+            ...base,
+            ...raw,
+            providers: { ...base.providers, ...(raw.providers || {}) },
+            contentPolicy: { ...base.contentPolicy, ...(raw.contentPolicy || {}) },
+            context: { ...base.context, ...(raw.context || {}) },
+            footer: {
+                ...base.footer,
+                ...(raw.footer || {}),
+                // Merged rather than replaced: a tenant who states their negotiated
+                // price for one model still gets the catalog for the rest.
+                pricing: { ...base.footer.pricing, ...(raw.footer?.pricing || {}) },
+            },
+        };
+    }
+    catch {
+        // A corrupt config must not stop someone working. Fail open to defaults.
+        return defaultConfig();
+    }
+}
+function saveConfig(cfg) {
+    ensureHome();
+    const out = { ...cfg, updated: new Date().toISOString() };
+    const p = configPath();
+    node_fs_1.default.writeFileSync(p, `${JSON.stringify(out, null, 2)}\n`, { mode: 0o600 });
+}
+const ENV_VAR = {
+    anthropic: 'ANTHROPIC_API_KEY',
+    openai: 'OPENAI_API_KEY',
+};
+/**
+ * Resolve keys for every enabled provider. Environment first, then the
+ * configured key command. A provider whose key does not resolve is simply not
+ * available; that is not an error until something tries to call it.
+ */
+function resolveKeys(cfg) {
+    const keys = {};
+    for (const provider of Object.keys(ENV_VAR)) {
+        if (!cfg.providers[provider]?.enabled)
+            continue;
+        const fromEnv = process.env[ENV_VAR[provider]];
+        if (fromEnv && fromEnv.trim()) {
+            keys[provider] = fromEnv.trim();
+            continue;
+        }
+        // NO SHELL COMMAND IS RUN TO FETCH A KEY.
+        //
+        // A `keyCommand` was a stored shell line that printed a vendor credential,
+        // and the tool used to write one automatically after importing keys from a
+        // file. Running it meant the machine went and fetched a secret locally on
+        // every call, which is the behavior the owner ruled out on 17 September
+        // 2026, and it meant a settings file on a laptop contained a working
+        // instruction for obtaining somebody's vendor credentials.
+        //
+        // An existing `keyCommand` left over from an older copy of the tool is now
+        // simply ignored rather than obeyed. The field stays in the type so that
+        // reading an older settings file does not fail; nothing acts on it.
+        //
+        // What remains here is the environment variable, and it has exactly ONE
+        // job: DISCOVERY, so `comprism keys` can offer to store a key the person
+        // already has when their ACCOUNT has none. It is never the answer to
+        // "does this account have a key", and it is never sent with a question.
+    }
+    return keys;
+}
+function availableProviders(keys) {
+    return Object.keys(keys).filter((p) => !!keys[p]);
+}
+/** Where the key for a provider would come from, for `setup` to report. */
+function keySource(cfg, provider) {
+    if (process.env[ENV_VAR[provider]]?.trim())
+        return 'env';
+    if (cfg.providers[provider]?.keyCommand?.trim())
+        return 'command';
+    return 'none';
+}
+function envVarName(provider) {
+    return ENV_VAR[provider];
+}

package/out/lib/connection.d.ts

@@ -0,0 +1,73 @@
+export interface Connection {
+    /** Tenant base URL, e.g. https://acme.completionprism.ai */
+    url: string;
+    /** Our own session token for that tenant. Never a provider key. */
+    token: string;
+    /**
+     * The workspace key this machine presents on every intercepted request.
+     *
+     * A different object from `token` and deliberately so. The session token is
+     * short-lived and belongs to a browser sign-in; this is a long-lived machine
+     * credential minted for this laptop, listed in the portal beside every other
+     * machine, and revocable on its own without signing anybody out. Without one,
+     * the tenant refuses interception - so the install writes NO base URL at all
+     * rather than pointing tools at a door that will turn them away.
+     */
+    workspaceKey?: string;
+    /** Only needed on localhost, where there is no subdomain to resolve. */
+    tenant?: string;
+    /** Minutes between unattended syncs. 0 turns automatic sync off. */
+    everyMinutes: number;
+    /** When a sync last succeeded, so `status` can say how fresh the portal is. */
+    lastSyncedAt?: string;
+    /** The last failure, kept so a quiet problem is still a visible one. */
+    lastError?: string;
+    connectedAt: string;
+}
+export declare function connectionPath(): string;
+export declare function readConnection(): Connection | null;
+/**
+ * Is this address a machine on somebody's desk rather than a workspace.
+ *
+ * Loopback, the link-local range, and the three private network ranges. A
+ * hostname that is not an address at all is a workspace by definition, because
+ * nobody's laptop is reachable by name from anywhere else.
+ */
+export declare function isLocalAddress(url: string): boolean;
+/**
+ * The fence, and it sits at the moment of WRITING rather than of reading.
+ *
+ * ── The incident ──────────────────────────────────────────────────────────
+ *
+ * On 17 September 2026 a developer's own machine had this file pointing at
+ * `http://localhost:8009`. Nothing listened there, so every call failed, and
+ * the product told him his account had no provider keys, no plan and no name.
+ * Four keys were stored and active the whole time.
+ *
+ * Two separate mechanisms put that address there, and either alone is enough to
+ * do it again: the workspace lookup preferred a laptop when a development
+ * environment variable was set, and a development server answers the "where do
+ * I sign in" question with its own laptop address, which the tool then believed.
+ *
+ * ── Why the fence is here and not at every read ───────────────────────────
+ *
+ * The bad address enters ONCE and is then believed for ever. Checking at read
+ * time means checking in eleven places and missing one. Checking here means a
+ * server's answer can never install a laptop address, whatever the server says,
+ * and a person who genuinely wants one has to say so in the same breath.
+ *
+ * `typed` is true only when the person put the address on the command line in
+ * this same run. Not an environment variable, not a stored file, not a server's
+ * reply. Those are the three routes that produced the fault.
+ */
+export declare function writeConnection(connection: Connection, typed?: boolean): void;
+export declare function clearConnection(): boolean;
+/** Record the outcome of a sync without disturbing anything else. */
+export declare function noteSync(ok: boolean, error?: string): void;
+/**
+ * Why the last enrollment attempt failed, in the tenant's own words.
+ *
+ * A module-level value rather than a thrown error, because failing to enrol is
+ * NOT a failure to sign in: the person is signed in either way, and the
+ * difference is only whether this machine can ask for work yet.
+ */

package/out/lib/connection.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectionPath = connectionPath;
+exports.readConnection = readConnection;
+exports.isLocalAddress = isLocalAddress;
+exports.writeConnection = writeConnection;
+exports.clearConnection = clearConnection;
+exports.noteSync = noteSync;
+/**
+ * The tenant connection: told to us once, then never asked for again.
+ *
+ * ── Why this file exists ──────────────────────────────────────────────────
+ *
+ * Sync started life as a command you ran by hand with a URL and a token on the
+ * line. That is defensible for a one-off and indefensible as a product: it
+ * makes the person the transport. Work recorded on a laptop only reaches the
+ * portal if somebody remembers to type something, so the portal is permanently
+ * behind, and "why is my session not showing up" becomes the commonest question
+ * about a product whose entire pitch is completeness.
+ *
+ * So the connection is stored once, and the recorder carries the records itself.
+ *
+ * ── What is stored, and the line that is not crossed ──────────────────────
+ *
+ * The endpoint, the tenant and OUR OWN session token, in a 0600 file inside the
+ * 0700 home directory. That is a different object from a provider API key, and
+ * the distinction is deliberate rather than convenient:
+ *
+ *   - A provider key (Anthropic, OpenAI) is the customer's money. It is never
+ *     written to disk by this product, in any file, ever. It is resolved from
+ *     the environment or a key command at the moment it is needed.
+ *   - A tenant token is a credential for OUR api, scoped to one tenant, held by
+ *     the same person who owns the records it carries, and revocable by them.
+ *     Storing it is what makes unattended sync possible at all.
+ *
+ * An expired token is not worth interrupting anyone over: the recorder keeps
+ * recording, the local store keeps its evidence, and the next `comprism connect`
+ * catches everything up. Nothing is lost by a failed sync, because sync is
+ * additive and never deletes the local record.
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("./config");
+function connectionPath() {
+    return node_path_1.default.join((0, config_1.homeDir)(), 'connection.json');
+}
+function readConnection() {
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(connectionPath(), 'utf8'));
+        // A machine enrolled by the one-line installer has a workspace key and no
+        // session token, and that is a complete, usable connection: it can be
+        // intercepted and measured. Requiring a token here silently discarded it.
+        return parsed.url && (parsed.token || parsed.workspaceKey) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Is this address a machine on somebody's desk rather than a workspace.
+ *
+ * Loopback, the link-local range, and the three private network ranges. A
+ * hostname that is not an address at all is a workspace by definition, because
+ * nobody's laptop is reachable by name from anywhere else.
+ */
+function isLocalAddress(url) {
+    let host;
+    try {
+        host = new URL(url).hostname.toLowerCase();
+    }
+    catch {
+        // UNPARSEABLE COUNTS AS LOCAL.
+        //
+        // This returned false, which meant anything the URL parser could not read
+        // was waved through as a workspace. `localhost:8009` with no scheme is
+        // exactly such a string, and it is the form our own help text suggests. A
+        // fence that opens when it cannot see is not a fence.
+        return true;
+    }
+    // `new URL` keeps IPv6 hosts in brackets. Strip them before comparing.
+    if (host.startsWith('[') && host.endsWith(']'))
+        host = host.slice(1, -1);
+    if (!host)
+        return true;
+    if (host === 'localhost' || host.endsWith('.local') || host.endsWith('.localhost'))
+        return true;
+    if (host === '::1' || host === '0:0:0:0:0:0:0:1' || host === '::')
+        return true;
+    // Unique local addresses, fc00::/7. Both halves of the range.
+    if (/^f[cd][0-9a-f]{0,2}:/.test(host))
+        return true;
+    // IPv4-mapped IPv6, ::ffff:127.0.0.1, so the v4 rules below still apply.
+    const mapped = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/.exec(host);
+    if (mapped && mapped[1])
+        host = mapped[1];
+    // Every dotted form node accepts, including the short ones: `127.1` is a
+    // loopback address and reads as a hostname to a naive four-part pattern.
+    const parts = host.split('.');
+    if (parts.length < 2 || parts.length > 4)
+        return false;
+    if (!parts.every((p) => /^\d{1,10}$/.test(p)))
+        return false;
+    const a = Number(parts[0] ?? '');
+    const b = parts.length >= 3 ? Number(parts[1] ?? '') : 0;
+    return a === 0 // 0.0.0.0 and anything in 0/8
+        || a === 127 // loopback, including 127.1
+        || a === 10 // private
+        || (a === 172 && b >= 16 && b <= 31) // private
+        || (a === 192 && b === 168) // private
+        || (a === 169 && b === 254); // link-local
+}
+/**
+ * The fence, and it sits at the moment of WRITING rather than of reading.
+ *
+ * ── The incident ──────────────────────────────────────────────────────────
+ *
+ * On 17 September 2026 a developer's own machine had this file pointing at
+ * `http://localhost:8009`. Nothing listened there, so every call failed, and
+ * the product told him his account had no provider keys, no plan and no name.
+ * Four keys were stored and active the whole time.
+ *
+ * Two separate mechanisms put that address there, and either alone is enough to
+ * do it again: the workspace lookup preferred a laptop when a development
+ * environment variable was set, and a development server answers the "where do
+ * I sign in" question with its own laptop address, which the tool then believed.
+ *
+ * ── Why the fence is here and not at every read ───────────────────────────
+ *
+ * The bad address enters ONCE and is then believed for ever. Checking at read
+ * time means checking in eleven places and missing one. Checking here means a
+ * server's answer can never install a laptop address, whatever the server says,
+ * and a person who genuinely wants one has to say so in the same breath.
+ *
+ * `typed` is true only when the person put the address on the command line in
+ * this same run. Not an environment variable, not a stored file, not a server's
+ * reply. Those are the three routes that produced the fault.
+ */
+function writeConnection(connection, typed = false) {
+    if (!typed && isLocalAddress(connection.url)) {
+        throw new Error(`refusing to point this machine at ${connection.url}, which is this computer `
+            + 'rather than a workspace. Pass it with --workspace if that is genuinely what you want.');
+    }
+    (0, config_1.ensureHome)();
+    node_fs_1.default.writeFileSync(connectionPath(), `${JSON.stringify(connection, null, 2)}\n`, { mode: 0o600 });
+    try {
+        node_fs_1.default.chmodSync(connectionPath(), 0o600);
+    }
+    catch {
+        /* a filesystem that cannot chmod is not a reason to fail */
+    }
+}
+function clearConnection() {
+    try {
+        node_fs_1.default.rmSync(connectionPath(), { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Record the outcome of a sync without disturbing anything else. */
+function noteSync(ok, error) {
+    const connection = readConnection();
+    if (!connection)
+        return;
+    if (ok) {
+        connection.lastSyncedAt = new Date().toISOString();
+        delete connection.lastError;
+    }
+    else {
+        connection.lastError = error || 'sync failed';
+    }
+    // `true`: this is bookkeeping on a connection that already exists and was
+    // already allowed. The fence is about how an address gets INSTALLED, and
+    // refusing a sync timestamp on a machine legitimately pointed at a local
+    // server would throw out of a background timer nobody is catching.
+    writeConnection(connection, true);
+}
+/**
+ * Why the last enrollment attempt failed, in the tenant's own words.
+ *
+ * A module-level value rather than a thrown error, because failing to enrol is
+ * NOT a failure to sign in: the person is signed in either way, and the
+ * difference is only whether this machine can ask for work yet.
+ */