fullcourtdefense-cli 1.34.21 → 1.34.25

package/dist/commands/protectedRun.js

@@ -0,0 +1,207 @@
+"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.ContainedLaunchFailure = void 0;
+exports.verifiedProtectionProfile = verifiedProtectionProfile;
+exports.protectedRunCommand = protectedRunCommand;
+exports.runProtectedLaunch = runProtectedLaunch;
+exports.containedExecutionEnvironment = containedExecutionEnvironment;
+exports.runContainedCommand = runContainedCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const url_1 = require("url");
+const config_1 = require("../config");
+const runtimeConfig_1 = require("../runtimeConfig");
+const machineIdentity_1 = require("../machineIdentity");
+const machineActionVerify_1 = require("../machineActionVerify");
+const protectionProfile_1 = require("../protectionProfile");
+const containmentLease_1 = require("../containmentLease");
+const telemetry_1 = require("../telemetry");
+function verifiedProtectionProfile(envelope, machineId, shieldId) {
+    if (!envelope || envelope.type !== 'protection_profile' || envelope.machineId !== machineId || !envelope.organizationId || !envelope.signature)
+        throw new Error('No signed protection settings for this computer.');
+    const created = Date.parse(envelope.createdAt), expires = Date.parse(envelope.expiresAt);
+    if (!Number.isFinite(created) || !Number.isFinite(expires) || created > Date.now() + 60_000 || expires <= Date.now() || expires - created > 24 * 60 * 60_000)
+        throw new Error('Protection settings expired or have invalid dates. Reconnect before launching.');
+    const verdict = (0, machineActionVerify_1.verifyMachineAction)(envelope, { localMachineId: machineId });
+    if (!verdict.ok || verdict.reason)
+        throw new Error('Protection settings failed signature verification.');
+    const payload = JSON.parse(envelope.reason);
+    if (!shieldId || payload.shieldId !== shieldId)
+        throw new Error('Protection settings belong to another enrollment.');
+    return (0, protectionProfile_1.parseProtectionProfile)(payload.profile);
+}
+async function protectedRunCommand(config, command, inspect = false) {
+    const identity = (0, machineIdentity_1.getMachineIdentity)();
+    const creds = (0, config_1.resolveCliCredentials)(config);
+    if (!creds.shieldId)
+        throw new Error('Enroll this computer before using managed protection.');
+    const bundle = await (0, runtimeConfig_1.getRuntimeBundle)({ apiUrl: creds.apiUrl, shieldId: creds.shieldId, shieldKey: creds.shieldKey, machineId: identity.machineId,
+        developerName: identity.developerName, machineName: identity.hostname, force: true, timeoutMs: 5000 });
+    if (bundle.suspended)
+        throw new Error('This computer is suspended.');
+    const profile = verifiedProtectionProfile(bundle.protectionProfile, identity.machineId, creds.shieldId);
+    if (profile.platform !== process.platform)
+        throw new Error('The protection profile is for a different operating system.');
+    if (inspect) {
+        console.log(JSON.stringify({ profile, revision: bundle.protectionProfile.id, expiresAt: bundle.protectionProfile.expiresAt, status: 'configured', enforcing: false }, null, 2));
+        return;
+    }
+    if (!command || command.length > 32000)
+        throw new Error('Provide --command with the command to launch.');
+    if (!fs.statSync(profile.workspace).isDirectory())
+        throw new Error('The working folder is unavailable.');
+    // The existing action checker remains authoritative for the initial command.
+    const hook = (0, child_process_1.spawnSync)(process.execPath, [path.resolve(__dirname, '../index.js'), 'hook', '--event', 'shell'], {
+        input: JSON.stringify({ command, cwd: profile.workspace, conversation_id: `protected-run-${process.pid}` }), cwd: profile.workspace,
+        encoding: 'utf8', timeout: 15000, maxBuffer: 1024 * 1024, windowsHide: true,
+    });
+    let verdict = {};
+    try {
+        verdict = JSON.parse(hook.stdout || '{}');
+    }
+    catch { /* failed checker blocks launch */ }
+    if (hook.error || hook.status !== 0 || verdict.permission !== 'allow')
+        throw new Error('The action checker did not allow this launch. Resolve its decision before retrying.');
+    process.exitCode = await runProtectedLaunch(profile, command, bundle.protectionProfile.id);
+}
+/** Existing machine Activity receives minimized launch outcome evidence. */
+class ContainedLaunchFailure extends Error {
+    executionStarted;
+    constructor(message, executionStarted) {
+        super(message);
+        this.executionStarted = executionStarted;
+    }
+}
+exports.ContainedLaunchFailure = ContainedLaunchFailure;
+async function runProtectedLaunch(profile, command, revision, launch = runContainedCommand) {
+    const record = (decision, reason) => {
+        try {
+            (0, telemetry_1.spoolEvent)({ decision, toolName: 'shell', operation: 'containment:launch', ruleId: `protection-profile:${revision}`, reason });
+            (0, telemetry_1.triggerFlush)(decision === 'block');
+        }
+        catch { /* Telemetry cannot change the launch result. */ }
+    };
+    try {
+        const code = await launch(profile, command);
+        record(code === 0 ? 'allow' : 'warn', `Protected launcher exited with code ${code}. This records the launch outcome, not a boundary test.`);
+        return code;
+    }
+    catch (error) {
+        const started = error instanceof ContainedLaunchFailure && error.executionStarted;
+        record(started ? 'warn' : 'block', started
+            ? 'Protected execution started, but the launcher or cleanup failed. This is not a blocked-action claim.'
+            : 'Protected launch could not start. No ordinary-shell fallback was used.');
+        throw error;
+    }
+}
+function containedExecutionEnvironment(source) {
+    const env = { ...source };
+    for (const key of Object.keys(env))
+        if (/^(NODE_OPTIONS|NODE_PATH|BASH_ENV|ENV|LD_.*|DYLD_.*|.*_PROXY)$/i.test(key))
+            delete env[key];
+    return env;
+}
+/** Runtime adapter, shared with real-process OS acceptance tests. */
+async function runContainedCommand(value, command) {
+    const profile = (0, protectionProfile_1.parseProtectionProfile)(value);
+    if (profile.platform !== process.platform)
+        throw new Error('Profile operating system mismatch.');
+    if (!command || command.length > 32000)
+        throw new Error('Invalid launch command.');
+    // Keep the ESM runtime lazy: existing hooks and older Node versions never load it.
+    const runtimeRoot = path.resolve(__dirname, '../containment-runtime');
+    const runtime = await new Function('url', 'return import(url)')((0, url_1.pathToFileURL)(path.join(runtimeRoot, 'index.mjs')).href);
+    const settings = (0, protectionProfile_1.protectionRuntimeSettings)(profile);
+    const helper = process.platform === 'win32' ? path.join(runtimeRoot, 'vendor/srt-win', process.arch, 'srt-win.exe') : undefined;
+    if (helper && !fs.existsSync(helper))
+        throw new Error('The Windows containment helper is missing. Repair the CLI installation before launching.');
+    const lease = await (0, containmentLease_1.acquireContainmentLease)();
+    let leaseLost = false;
+    let running;
+    let executionStarted = false;
+    void lease.lost.then(() => { leaseLost = true; running?.kill(); });
+    try {
+        // srt-win's bulk session stamp loses read denial when the same path is
+        // also supplied as denyWrite. Keep read denial held by the session and
+        // apply write denial through the runtime's separate per-exec holder.
+        await runtime.SandboxManager.initialize({ ...settings, ...(helper ? { filesystem: { ...settings.filesystem, denyWrite: [] }, windows: { srtWin: { path: helper } } } : {}) });
+        if (!runtime.SandboxManager.isSupportedPlatform() || !runtime.SandboxManager.isSandboxingEnabled() || !await runtime.SandboxManager.waitForNetworkInitialization())
+            throw new Error('Containment is unavailable. The command was not started.');
+        const env = containedExecutionEnvironment(process.env);
+        let executable, args, childEnv = env;
+        if (process.platform === 'win32') {
+            const wrapped = await runtime.SandboxManager.wrapWithSandboxArgv(command, undefined, { filesystem: { allowWrite: [], denyRead: [], denyWrite: settings.filesystem.denyWrite } }, undefined, profile.workspace);
+            executable = wrapped.argv[0];
+            args = wrapped.argv.slice(1);
+            childEnv = { ...env, ...wrapped.env };
+        }
+        else {
+            executable = '/bin/sh';
+            args = ['-c', await runtime.SandboxManager.wrapWithSandbox(command)];
+        }
+        console.error(`Starting contained execution with profile "${profile.name}". Existing processes are unaffected.`);
+        if (leaseLost)
+            throw new Error('Containment lock was lost before launch.');
+        return await new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(executable, args, { cwd: profile.workspace, env: childEnv, shell: false, stdio: 'inherit', windowsHide: true });
+            running = child;
+            child.once('spawn', () => { executionStarted = true; });
+            child.once('error', reject);
+            child.once('close', code => { running = undefined; resolve(leaseLost ? 1 : code ?? 1); });
+        });
+    }
+    catch (error) {
+        throw new ContainedLaunchFailure(error instanceof Error ? error.message : 'Contained execution failed.', executionStarted);
+    }
+    finally {
+        let cleanupError;
+        try {
+            await runtime.SandboxManager.reset();
+        }
+        catch (error) {
+            cleanupError = error;
+        }
+        try {
+            await lease.release();
+        }
+        catch (error) {
+            cleanupError ||= error;
+        }
+        if (cleanupError)
+            throw new ContainedLaunchFailure('Containment cleanup failed. Check the endpoint before another launch.', executionStarted);
+    }
+}