@illuminis/comprism 0.1.0

package/out/commands/install.js

@@ -0,0 +1,543 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKSPACE_KEY_HEADER = void 0;
+exports.envScriptPath = envScriptPath;
+exports.pidFilePath = pidFilePath;
+exports.proxyLogPath = proxyLogPath;
+exports.shellProfiles = shellProfiles;
+exports.tenantBaseUrl = tenantBaseUrl;
+exports.envScript = envScript;
+exports.desktopConfigPath = desktopConfigPath;
+exports.installDesktopConnector = installDesktopConnector;
+exports.probeDesktopConnector = probeDesktopConnector;
+exports.uninstallDesktopConnector = uninstallDesktopConnector;
+exports.install = install;
+exports.uninstall = uninstall;
+exports.launchShellString = launchShellString;
+exports.proxyHealthy = proxyHealthy;
+exports.startDaemon = startDaemon;
+exports.stopDaemon = stopDaemon;
+/**
+ * Install and interception setup. Rules R1 and R2.
+ *
+ * R1 says one command installs everything, with nothing for the user to copy or
+ * paste. R2 says `claude` then just works, unchanged. Those two together rule
+ * out the obvious approach - printing an `export` line and hoping - so this file
+ * does the work instead.
+ *
+ * ── What the base URL points at, and why it is not this machine ───────────
+ *
+ * The tenant's own hosted endpoint: `https://{tenant}.completionprism.illuminis.ai`.
+ * Claude Code and every Anthropic SDK append `/v1/messages` to it themselves.
+ *
+ * It used to point at a proxy on 127.0.0.1 that this script started, and that
+ * was wrong in a way worth writing down, because it looked right for weeks. A
+ * local proxy means the pricing runs on the laptop, which means a second
+ * implementation of the equation in a second language - and those two drifted
+ * inside a day the first time, leaving two surfaces quoting different costs for
+ * the same work. It also means nothing is measured on any machine where the
+ * daemon is not running, and no receipt link that a colleague can open. One
+ * hosted interceptor removes all three at once: the CLI now renders and strips,
+ * and computes nothing.
+ *
+ * ── The shape, and why it is safe ─────────────────────────────────────────
+ *
+ * The install writes `~/.comprism/env.sh` and adds one sourcing line to the
+ * user's shell profile. That script does two things every time a shell opens,
+ * in this order, and the order is the whole safety argument:
+ *
+ *   1. Is the tenant endpoint answering? If yes, export the base URL.
+ *   2. **If it is not, export nothing.**
+ *
+ * Step 2 is the important one. A base URL pointing somewhere unreachable would
+ * break every AI tool on the machine, and "our measurement tool broke Claude
+ * Code" is the single worst outcome this product can produce - worse by far than
+ * missing a day of data. So the failure mode is silence: the user's tools talk
+ * straight to the provider exactly as they did before, and we record nothing.
+ * That is rule 10 and it is not negotiable.
+ *
+ * ── Why a shell profile at all ────────────────────────────────────────────
+ *
+ * Because the requirement is that plain `claude` is instrumented. A wrapper
+ * command would be less invasive and would not satisfy that. The line is
+ * fenced with markers, `comprism uninstall` removes it exactly, and the install
+ * says out loud what it touched.
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const config_1 = require("../lib/config");
+const connection_1 = require("../lib/connection");
+/** The header the tenant reads to decide whether this machine may be served. */
+exports.WORKSPACE_KEY_HEADER = 'x-comprism-key';
+const MARKER_START = '# >>> comprism >>>';
+const MARKER_END = '# <<< comprism <<<';
+function envScriptPath() {
+    return node_path_1.default.join((0, config_1.homeDir)(), 'env.sh');
+}
+function pidFilePath() {
+    return node_path_1.default.join((0, config_1.homeDir)(), 'proxy.pid');
+}
+function proxyLogPath() {
+    return node_path_1.default.join((0, config_1.homeDir)(), 'proxy.log');
+}
+/** Every profile we should add the line to, that actually exists. */
+function shellProfiles() {
+    const home = node_os_1.default.homedir();
+    const candidates = ['.zshrc', '.bashrc', '.bash_profile', '.profile'];
+    const found = candidates
+        .map((f) => node_path_1.default.join(home, f))
+        .filter((p) => node_fs_1.default.existsSync(p));
+    // A machine with none of them: create the one matching the login shell rather
+    // than silently doing nothing.
+    if (found.length === 0) {
+        const shell = process.env.SHELL || '';
+        return [node_path_1.default.join(home, shell.includes('bash') ? '.bashrc' : '.zshrc')];
+    }
+    return found;
+}
+/**
+ * The tenant's own endpoint, and never anything on this machine.
+ *
+ * Three sources, most specific first: what the caller passed, the connection
+ * `comprism login` stored, and the tenant and domain in config. Null when none
+ * of them names a tenant, and null is load-bearing - the install then writes a
+ * script that exports nothing rather than one that guesses a hostname.
+ */
+function tenantBaseUrl(explicit) {
+    const clean = (url) => url.replace(/\/+$/, '');
+    if (explicit)
+        return clean(explicit);
+    const connection = (0, connection_1.readConnection)();
+    if (connection?.url)
+        return clean(connection.url);
+    const cfg = (0, config_1.loadConfig)();
+    const portal = cfg.footer?.portal || {};
+    const slug = (cfg.footer?.tenant || '').trim().toLowerCase().replace(/[^a-z0-9-]/g, '');
+    const domain = portal.domain || 'completionprism.illuminis.ai';
+    return slug ? `https://${slug}.${domain}` : null;
+}
+/**
+ * The script every new shell sources.
+ *
+ * Written as POSIX shell so it works in bash and zsh alike, and deliberately
+ * silent: a shell startup file that prints things is a shell startup file people
+ * delete.
+ *
+ * `OPENAI_BASE_URL` is deliberately NOT set. The hosted interceptor speaks the
+ * Anthropic shape today, so pointing an OpenAI client at it would send that
+ * client somewhere with no route for it - breaking a working tool in order to
+ * measure it, which is the one thing this file exists to prevent. It comes back
+ * the day there is an OpenAI-shaped endpoint to point at.
+ */
+function envScript(baseUrl, workspaceKey) {
+    if (!baseUrl) {
+        return `#!/bin/sh
+# Managed by comprism. Edit nothing here; run \`comprism install\` to regenerate.
+#
+# No tenant is connected yet, so this exports nothing and your tools are
+# untouched. Run \`comprism login\` and then \`comprism install\` again.
+`;
+    }
+    // A base URL with no workspace key points every AI tool on this machine at a
+    // door that will refuse it. That is worse than not measuring: it breaks work
+    // in order to measure it, which rule 10 forbids outright. So an unenrolled
+    // machine exports NOTHING and talks to the provider exactly as before.
+    if (!workspaceKey) {
+        return `#!/bin/sh
+# Managed by comprism. Edit nothing here; run \`comprism install\` to regenerate.
+#
+# This machine is not enrolled in a CompletionPrism workspace, so it exports
+# nothing and your tools are untouched. Run \`comprism login\` to enroll it.
+`;
+    }
+    return `#!/bin/sh
+# Managed by comprism. Edit nothing here; run \`comprism install\` to regenerate.
+#
+# Points AI clients at your CompletionPrism tenant so your work is measured.
+# If the tenant is not reachable, this exports NOTHING and your tools talk
+# straight to the provider exactly as they would without us. Measurement is
+# never worth breaking someone's work over.
+
+__comprism_alive() {
+  curl -s -m 2 -o /dev/null "${baseUrl}/health" 2>/dev/null
+}
+
+if __comprism_alive; then
+  ANTHROPIC_BASE_URL="${baseUrl}"
+  export ANTHROPIC_BASE_URL
+
+  # Who this machine is, presented on every request. Anthropic clients read
+  # ANTHROPIC_CUSTOM_HEADERS as "Name: value" lines, so nothing has to be pasted
+  # into a tool's own configuration. An existing value is added to rather than
+  # replaced: it may well be carrying a corporate proxy's header, and taking that
+  # away to install ourselves would break the very thing we promise not to.
+  __comprism_header="${exports.WORKSPACE_KEY_HEADER}: ${workspaceKey}"
+  case "$ANTHROPIC_CUSTOM_HEADERS" in
+    *"${exports.WORKSPACE_KEY_HEADER}"*) : ;;
+    "") ANTHROPIC_CUSTOM_HEADERS="$__comprism_header" ;;
+    *) ANTHROPIC_CUSTOM_HEADERS="$ANTHROPIC_CUSTOM_HEADERS
+$__comprism_header" ;;
+  esac
+  export ANTHROPIC_CUSTOM_HEADERS
+  unset __comprism_header
+fi
+
+unset -f __comprism_alive 2>/dev/null || true
+`;
+}
+/**
+ * Where the desktop client keeps its connector list, per platform.
+ *
+ * Only the directory the client itself created counts. Creating it ourselves on
+ * a machine with no desktop client would leave a config file for an application
+ * that is not installed, which is litter.
+ */
+function desktopConfigPath() {
+    const home = node_os_1.default.homedir();
+    if (process.platform === 'darwin') {
+        return node_path_1.default.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    if (process.platform === 'win32') {
+        return node_path_1.default.join(process.env.APPDATA || node_path_1.default.join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+    }
+    return node_path_1.default.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+}
+/**
+ * Take our STDIO entry back out of Claude Desktop's config, and say what to add
+ * instead.
+ *
+ * This used to REGISTER a stdio server here - `node cli.js mcp` - and that was
+ * wrong in a way that cost a real afternoon. That server exposes `record_work`,
+ * `completion_receipt` and `coverage`: it only ever OBSERVES. It does not route,
+ * it does not answer, so there is no receipt for the client to render, and it
+ * appends to `~/.comprism/ledger.jsonl` on this laptop rather than to the
+ * tenant, so nothing it records can ever appear in the portal. The install then
+ * printed "Claude Desktop connector registered and answering", which was true of
+ * the handshake and false about the product.
+ *
+ * The connector that works is the hosted one, `{tenant}/mcp`, which runs the
+ * same nine steps as every other surface, returns the answer with the receipt
+ * attached, and writes the turn to the tenant. It is added by pasting its
+ * address into Claude Desktop's own Connectors dialog, because a remote
+ * connector is authorized by an OAuth consent screen that only the person
+ * sitting there can approve - there is nothing an installer could write into a
+ * file to stand in for that.
+ *
+ * So this now does the honest thing: removes a stale entry of ours if one is
+ * there, never writes one, and returns the address for the caller to print. Two
+ * things it still will never do: create the file on a machine where the desktop
+ * client is not installed, and overwrite a config it could not parse.
+ */
+function installDesktopConnector(_binary) {
+    const configPath = desktopConfigPath();
+    const dir = node_path_1.default.dirname(configPath);
+    if (!node_fs_1.default.existsSync(dir)) {
+        return {
+            configPath,
+            present: false,
+            registered: false,
+            staleRemoved: false,
+            note: 'Claude Desktop is not installed on this machine, so there is nothing to add here.',
+        };
+    }
+    if (!node_fs_1.default.existsSync(configPath)) {
+        return { configPath, present: true, registered: false, staleRemoved: false };
+    }
+    let config;
+    try {
+        config = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+    }
+    catch {
+        return {
+            configPath,
+            present: true,
+            registered: false,
+            staleRemoved: false,
+            note: 'The desktop config could not be read as JSON, so it was left exactly as it is. '
+                + 'Nothing was changed.',
+        };
+    }
+    // Only ever REMOVE, and only our own key. An earlier version of this installer
+    // wrote a stdio server here that could not produce a receipt or reach the
+    // tenant; leaving it behind means the client keeps offering the wrong tools
+    // beside the right ones, and the person cannot tell which is which.
+    const servers = config.mcpServers;
+    if (!servers || !servers.completionprism) {
+        return { configPath, present: true, registered: false, staleRemoved: false };
+    }
+    delete servers.completionprism;
+    if (Object.keys(servers).length === 0)
+        delete config.mcpServers;
+    else
+        config.mcpServers = servers;
+    node_fs_1.default.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+    return { configPath, present: true, registered: false, staleRemoved: true };
+}
+/**
+ * Start the connector exactly as the desktop client will, and see if it answers.
+ *
+ * Written after a live failure that the installer had already called a success.
+ * `npm install -g .` from a checkout leaves the global package as a SYMLINK back
+ * into the source folder; on macOS the desktop client is sandboxed out of
+ * `~/Documents`, so the connector died on `EPERM` the moment it was launched -
+ * and the only trace was a log file nobody thinks to open. The installer said
+ * "registered", which was true and useless.
+ *
+ * So registration is no longer the claim. This spawns the real command, speaks
+ * the real handshake and waits for the real reply. A connector that cannot start
+ * is reported as broken, with the reason, at install time.
+ */
+async function probeDesktopConnector(binary) {
+    const { command, args: baseArgs } = binary;
+    return new Promise((resolve) => {
+        let settled = false;
+        let child;
+        const done = (ok, detail) => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                child?.kill();
+            }
+            catch {
+                /* already gone */
+            }
+            resolve({ ok, detail });
+        };
+        try {
+            child = (0, node_child_process_1.spawn)(command, [...baseArgs, 'mcp'], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch (err) {
+            resolve({
+                ok: false,
+                detail: err instanceof Error ? err.message : 'the connector could not be started',
+            });
+            return;
+        }
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (d) => {
+            stdout += String(d);
+            if (stdout.includes('"serverInfo"'))
+                done(true, 'answered the handshake');
+        });
+        child.stderr?.on('data', (d) => {
+            stderr += String(d);
+        });
+        child.on('error', (err) => done(false, err.message));
+        child.on('exit', () => {
+            // The first meaningful line of a crash is the useful one; the stack is
+            // noise in an install report.
+            const first = stderr.split('\n').find((l) => /Error|error|EPERM|not found/.test(l));
+            done(false, first?.trim() || 'the connector exited without answering');
+        });
+        child.stdin?.write(`${JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'initialize',
+            params: {
+                protocolVersion: '2025-06-18',
+                capabilities: {},
+                clientInfo: { name: 'comprism-install-probe', version: '1' },
+            },
+        })}\n`);
+        setTimeout(() => done(false, 'the connector did not answer within three seconds'), 3000);
+    });
+}
+/** Take the connector back out, leaving every other server alone. */
+function uninstallDesktopConnector() {
+    const configPath = desktopConfigPath();
+    if (!node_fs_1.default.existsSync(configPath))
+        return false;
+    let config;
+    try {
+        config = JSON.parse(node_fs_1.default.readFileSync(configPath, 'utf8'));
+    }
+    catch {
+        return false;
+    }
+    const servers = config.mcpServers;
+    if (!servers || !servers.completionprism)
+        return false;
+    delete servers.completionprism;
+    node_fs_1.default.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+    return true;
+}
+/**
+ * Do the setup. Idempotent: running it twice changes nothing the second time.
+ */
+function install(options = {}) {
+    (0, config_1.ensureHome)();
+    // Prefer the globally installed binary; fall back to however we were invoked,
+    // so this works from a checkout as well as from an npm install.
+    const binary = options.binary ?? resolveBinary();
+    const baseUrl = tenantBaseUrl(options.baseUrl);
+    // Enrollment, not authentication: the tenant refuses interception to a machine
+    // that cannot say which workspace it belongs to, so this decides whether we
+    // configure anything at all.
+    const workspaceKey = options.workspaceKey ?? (0, connection_1.readConnection)()?.workspaceKey ?? null;
+    const scriptPath = envScriptPath();
+    node_fs_1.default.writeFileSync(scriptPath, envScript(baseUrl, workspaceKey), { mode: 0o700 });
+    const line = `${MARKER_START}\n[ -f "${scriptPath}" ] && . "${scriptPath}"\n${MARKER_END}`;
+    const touched = [];
+    const already = [];
+    for (const profile of shellProfiles()) {
+        let contents = '';
+        try {
+            contents = node_fs_1.default.readFileSync(profile, 'utf8');
+        }
+        catch {
+            contents = '';
+        }
+        if (contents.includes(MARKER_START)) {
+            // Replace the fenced block rather than appending a second one.
+            const next = contents.replace(new RegExp(`${MARKER_START}[\\s\\S]*?${MARKER_END}`), line);
+            if (next !== contents)
+                node_fs_1.default.writeFileSync(profile, next);
+            already.push(profile);
+            continue;
+        }
+        node_fs_1.default.appendFileSync(profile, `\n${line}\n`);
+        touched.push(profile);
+    }
+    return {
+        envScript: scriptPath,
+        profilesTouched: touched,
+        profilesAlreadyHad: already,
+        baseUrl,
+        enrolled: Boolean(workspaceKey),
+        binary,
+        // Absolute, deliberately: the desktop client is launched by launchd and
+        // has neither our shim nor node on its PATH. See `resolveDesktopBinary`.
+        desktop: installDesktopConnector(resolveDesktopBinary()),
+    };
+}
+/** Take the line back out. An install you cannot cleanly undo is a liability. */
+function uninstall() {
+    const cleaned = [];
+    for (const profile of shellProfiles()) {
+        let contents = '';
+        try {
+            contents = node_fs_1.default.readFileSync(profile, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (!contents.includes(MARKER_START))
+            continue;
+        const next = contents
+            .replace(new RegExp(`\\n?${MARKER_START}[\\s\\S]*?${MARKER_END}\\n?`), '\n')
+            .replace(/\n{3,}/g, '\n\n');
+        node_fs_1.default.writeFileSync(profile, next);
+        cleaned.push(profile);
+    }
+    uninstallDesktopConnector();
+    return { profilesCleaned: cleaned };
+}
+/** The shell form, quoted, for the profile script that must be a shell string. */
+function launchShellString(launch) {
+    return [launch.command, ...launch.args]
+        .map((part) => (/[\s"'\\]/.test(part) ? `"${part.replace(/(["\\])/g, '\\$1')}"` : part))
+        .join(' ');
+}
+function resolveBinary() {
+    const compiled = node_path_1.default.join(__dirname, 'cli.js');
+    if (!node_fs_1.default.existsSync(compiled)) {
+        // Not running from a build - fall back to the name on PATH.
+        return { command: 'comprism', args: [] };
+    }
+    // Prefer the bare name when the shim on PATH is this same package, so the
+    // config keeps working if the package moves. Verified rather than assumed:
+    // a `comprism` belonging to some other install would be worse than a path.
+    for (const dir of (process.env.PATH || '').split(node_path_1.default.delimiter)) {
+        const shim = node_path_1.default.join(dir, 'comprism');
+        try {
+            if (node_fs_1.default.existsSync(shim) && node_fs_1.default.realpathSync(shim) === node_fs_1.default.realpathSync(compiled)) {
+                return { command: 'comprism', args: [] };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return { command: process.execPath, args: [compiled] };
+}
+/**
+ * How to start the CLI from an application launched by the Dock.
+ *
+ * ALWAYS absolute, never the bare name, and that is the difference between a
+ * connector that works and one that says "Server disconnected" forever.
+ *
+ * A desktop client is started by launchd, not by a shell. It inherits none of
+ * `~/.zshrc`, so `PATH` is `/usr/bin:/bin:/usr/sbin:/sbin` and `comprism` is
+ * not on it. Neither is `node`, which matters just as much: the shim's shebang
+ * is `#!/usr/bin/env node`, so even an absolute path to `cli.js` would fail to
+ * start. Naming the interpreter AND the script outright is the only form that
+ * does not depend on an environment we do not control.
+ *
+ * The shell profile keeps using `resolveBinary()`, where the bare name is
+ * genuinely better because it survives the package moving.
+ */
+function resolveDesktopBinary() {
+    const compiled = node_path_1.default.join(__dirname, 'cli.js');
+    if (!node_fs_1.default.existsSync(compiled))
+        return resolveBinary();
+    return { command: process.execPath, args: [compiled] };
+}
+// ── the background service ──────────────────────────────────────────────────
+async function proxyHealthy(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/__comprism/health`, {
+            signal: AbortSignal.timeout(1000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Start the proxy detached, so it outlives the shell that started it.
+ *
+ * Returns whether it came up. Never throws: a service that fails to start is a
+ * missing measurement, and the caller's job is to carry on regardless.
+ */
+async function startDaemon(port) {
+    if (await proxyHealthy(port))
+        return true;
+    (0, config_1.ensureHome)();
+    const out = node_fs_1.default.openSync(proxyLogPath(), 'a');
+    const child = (0, node_child_process_1.spawn)(process.execPath, [process.argv[1], 'proxy', '--port', String(port)], {
+        detached: true,
+        stdio: ['ignore', out, out],
+    });
+    child.unref();
+    if (child.pid)
+        node_fs_1.default.writeFileSync(pidFilePath(), String(child.pid));
+    for (let i = 0; i < 25; i++) {
+        if (await proxyHealthy(port))
+            return true;
+        await new Promise((r) => setTimeout(r, 120));
+    }
+    return false;
+}
+function stopDaemon() {
+    try {
+        const pid = Number(node_fs_1.default.readFileSync(pidFilePath(), 'utf8').trim());
+        if (!pid)
+            return false;
+        process.kill(pid, 'SIGTERM');
+        node_fs_1.default.rmSync(pidFilePath(), { force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/out/commands/keys.d.ts

@@ -0,0 +1,55 @@
+/**
+ * What this workspace can reach, and whether we were able to ask.
+ *
+ * ── Why this returns three states and not a boolean ───────────────────────
+ *
+ * It used to return a boolean, and the boolean was the fault reported on
+ * 17 September 2026. The workspace could not be reached, the question therefore
+ * went unanswered, the local scan found nothing, and `false` came back. The
+ * session read `false` as "this account has no provider key" and walked a
+ * person with FOUR stored, active, working keys into a form asking them to
+ * paste one.
+ *
+ * "Nobody answered" and "the answer is none" are different facts and they need
+ * different words on screen, so they are different values here.
+ */
+export type KeyState = 
+/** The workspace answered and holds at least one vendor key. */
+{
+    reached: true;
+    hasKey: true;
+}
+/** The workspace answered and holds none. A real, actionable answer. */
+ | {
+    reached: true;
+    hasKey: false;
+}
+/** We never heard back, so NOTHING is known about the account's keys. */
+ | {
+    reached: false;
+    why: string;
+};
+/**
+ * What the workspace says it can reach.
+ *
+ * **The workspace is the only source of truth.** This function does not look at
+ * the machine, and no caller may treat a key found on the machine as an answer
+ * to this question. A key sitting in somebody's shell is not a key the account
+ * holds: it works for that one shell, it is invisible to the portal, to the
+ * editor and to their colleagues, and a product that counts it tells four
+ * different people four different things about the same account.
+ *
+ * The machine is still SEARCHED, but only in `offerLocalImport` below, and only
+ * once this has answered `{ reached: true, hasKey: false }`. That is the owner's
+ * rule of 17 September 2026: look on the computer when the account has nothing,
+ * and when something is found, store it on the server through the one service.
+ */
+export declare function keyState(): Promise<KeyState>;
+/**
+ * Kept for callers that genuinely only need a yes.
+ *
+ * Unreachable counts as NO here, and every caller must have already reported
+ * the unreachable case in its own words before calling this. Prefer `keyState`.
+ */
+export declare function hasAnyKey(): Promise<boolean>;
+export declare function cmdKeys(args: string[]): Promise<void>;