0sec-cli 0.21.4 → 0.22.1

package/chunks/{runtime-PXO5G6UV.js → runtime-H7YBR5IZ.js}

@@ -11,18 +11,17 @@ import {
   detectAvailableRuntimes,
   getRuntimeInfo,
   pickRuntimeForStage
-} from "./chunk-NDJU5ZZ7.js";
+} from "./chunk-IFME676H.js";
 import {
   ProcessRuntime
-} from "./chunk-ER3SUMYJ.js";
-import "./chunk-CXKDWFNO.js";
+} from "./chunk-W6UWZFKL.js";
 import {
   LlmApiRuntime,
   OperatorAbortError,
   QuotaExhaustedError,
   parseUsageLimitReached
-} from "./chunk-BACXRTQ4.js";
-import "./chunk-PC6RCKQV.js";
+} from "./chunk-AV2LG2L7.js";
+import "./chunk-KAU6NLGP.js";
 import "./chunk-VIT5ALXF.js";
 import "./chunk-VCSFCHAJ.js";
 export {

package/chunks/{scope-NJHIDDTN.js → scope-QWY4VQZ7.js}

@@ -7,7 +7,10 @@ import {
   loadScope,
   matchUrl,
   normalizeScopeHostname
-} from "./chunk-CGHCEN7W.js";
+} from "./chunk-X7LAEEUW.js";
+import "./chunk-5IBCBQEH.js";
+import "./chunk-KAU6NLGP.js";
+import "./chunk-VIT5ALXF.js";
 import "./chunk-VCSFCHAJ.js";
 export {
   ScopePolicy,

package/chunks/{session-store-46WBZM22.js → session-store-XIDFGG7K.js}

@@ -11,8 +11,8 @@ import {
   relativeAge,
   saveSession,
   sessionsDir
-} from "./chunk-NOPBXZUV.js";
-import "./chunk-PC6RCKQV.js";
+} from "./chunk-BOUGKEKA.js";
+import "./chunk-KAU6NLGP.js";
 import "./chunk-VIT5ALXF.js";
 import "./chunk-VCSFCHAJ.js";
 export {

package/chunks/{variant-candidates-UH2WC2HA.js → variant-candidates-7D4F5E4H.js}

@@ -3,9 +3,9 @@ import { createRequire as __0CreateRequire } from "node:module";
 const require = __0CreateRequire(import.meta.url);
 import {
   generateVariantCandidates
-} from "./chunk-TF46UWFU.js";
-import "./chunk-BACXRTQ4.js";
-import "./chunk-PC6RCKQV.js";
+} from "./chunk-4G7OVYJX.js";
+import "./chunk-AV2LG2L7.js";
+import "./chunk-KAU6NLGP.js";
 import "./chunk-VIT5ALXF.js";
 import "./chunk-VCSFCHAJ.js";
 export {

package/chunks/{web-recon-prepass-SFXU44SS.js → web-recon-prepass-VXXBPDAV.js}

@@ -6,13 +6,13 @@ import {
   fingerprintWebStack,
   runBaselineWebChecks,
   summarizeWebStackFingerprint
-} from "./chunk-Y5H6E24H.js";
+} from "./chunk-XCISCI4T.js";
 import {
   enumerateSubdomains,
   scanJsArtifacts,
   searchAdvisories
-} from "./chunk-SBMB4OL3.js";
-import "./chunk-PC6RCKQV.js";
+} from "./chunk-YL6YAGLL.js";
+import "./chunk-KAU6NLGP.js";
 import "./chunk-VIT5ALXF.js";
 import "./chunk-VCSFCHAJ.js";
 

package/cli-path-traversal-fixture.js

@@ -0,0 +1,352 @@
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { access, mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, resolve, sep } from "node:path";
+const FIXTURE_ID = "fixture:cli-path-traversal";
+const DEFAULT_TIMEOUT_MS = 10_000;
+const SIGKILL_GRACE_MS = 1_000;
+const CAPTURE_BYTES = 1024 * 1024;
+const EXCERPT_BYTES = 4 * 1024;
+function excerpt(text, max = EXCERPT_BYTES) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max) + "...[truncated]";
+}
+function isInside(root, candidate) {
+    return candidate === root || candidate.startsWith(root + sep);
+}
+async function exists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function appendCapped(current, chunk) {
+    if (current.length >= CAPTURE_BYTES)
+        return current;
+    const next = current + chunk.toString("utf8");
+    if (next.length <= CAPTURE_BYTES)
+        return next;
+    return next.slice(0, CAPTURE_BYTES) + "\n...[truncated at 1MiB]";
+}
+async function runCommand(argv, options) {
+    return await new Promise((resolveCommand) => {
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        let timedOut = false;
+        let timer;
+        let killTimer;
+        const child = spawn(argv[0], argv.slice(1), {
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            resolveCommand(result);
+        };
+        timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            killTimer = setTimeout(() => {
+                if (settled)
+                    return;
+                child.kill("SIGKILL");
+                finish({
+                    exitCode: null,
+                    stdout,
+                    stderr,
+                    timedOut,
+                    error: `command timed out after ${options.timeoutMs}ms and did not exit after SIGTERM`,
+                });
+            }, SIGKILL_GRACE_MS);
+        }, options.timeoutMs);
+        child.stdout?.on("data", (chunk) => {
+            stdout = appendCapped(stdout, chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr = appendCapped(stderr, chunk);
+        });
+        child.on("error", (err) => {
+            finish({
+                exitCode: null,
+                stdout,
+                stderr,
+                timedOut,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        });
+        child.on("close", (code) => {
+            finish({
+                exitCode: code,
+                stdout,
+                stderr,
+                timedOut,
+                error: timedOut ? `command timed out after ${options.timeoutMs}ms` : undefined,
+            });
+        });
+    });
+}
+async function startMaliciousExportServer() {
+    const payload = {
+        rootPath: "demo",
+        paperclipExtensionPath: null,
+        warnings: [],
+        files: {
+            "../escaped-marker": "0 deterministic verification\n",
+            "README.md": "normal export content\n",
+        },
+    };
+    const server = createServer((req, res) => {
+        if (req.method === "GET" && req.url === "/company/export") {
+            res.statusCode = 200;
+            res.setHeader("content-type", "application/json");
+            res.end(JSON.stringify(payload));
+            return;
+        }
+        res.statusCode = 404;
+        res.end("not found");
+    });
+    await new Promise((resolveListen, rejectListen) => {
+        server.once("error", rejectListen);
+        server.listen(0, "127.0.0.1", () => resolveListen());
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        await closeServer(server);
+        throw new Error("failed to allocate fixture server port");
+    }
+    return {
+        server,
+        baseUrl: `http://127.0.0.1:${address.port}`,
+    };
+}
+async function closeServer(server) {
+    await new Promise((resolveClose) => {
+        server.close(() => resolveClose());
+    });
+}
+function expandCommandArgv(argv, replacements) {
+    return argv.map((arg) => arg
+        .replaceAll("{{apiUrl}}", replacements.apiUrl)
+        .replaceAll("{{exportDir}}", replacements.exportDir)
+        .replaceAll("{{fixtureMode}}", replacements.fixtureMode));
+}
+function assertion(kind, passed, detail) {
+    return { kind, passed, detail };
+}
+async function buildAssertions(paths) {
+    const [sandboxReal, exportReal] = await Promise.all([
+        realpath(paths.sandboxRoot),
+        realpath(paths.exportDir),
+    ]);
+    const escapedExists = await exists(paths.escapedPath);
+    const insideExportExists = await exists(paths.insideExportPath);
+    let escapedReal = resolve(paths.escapedPath);
+    if (escapedExists) {
+        escapedReal = await realpath(paths.escapedPath);
+    }
+    const homeReal = await realpath(homedir()).catch(() => homedir());
+    const profileNames = new Set([".bashrc", ".zshrc", ".profile", ".bash_profile"]);
+    const escapedBase = escapedReal.split(sep).at(-1) ?? "";
+    const escapedInsideHome = isInside(homeReal, escapedReal);
+    const escapedMatchesProfile = profileNames.has(escapedBase);
+    const noHomeProfileTouch = !escapedInsideHome && !escapedMatchesProfile;
+    const noHomeProfileTouchDetail = escapedInsideHome
+        ? `touched path ${escapedReal} is inside home directory ${homeReal}`
+        : escapedMatchesProfile
+            ? `touched path ${escapedReal} matches profile basename ${escapedBase}`
+            : `touched path ${escapedReal} is not a home directory or shell profile target`;
+    return [
+        assertion("filesystem_exists", escapedExists, escapedExists
+            ? `escaped marker exists at ${escapedReal}`
+            : `escaped marker not found at ${paths.escapedPath}`),
+        assertion("filesystem_not_exists", !insideExportExists, insideExportExists
+            ? `unexpected marker found inside export root at ${paths.insideExportPath}`
+            : `no escaped marker exists inside export root at ${paths.insideExportPath}`),
+        assertion("path_outside_export_root", escapedExists && !isInside(exportReal, escapedReal), escapedExists
+            ? `escaped marker realpath ${escapedReal} is outside export root ${exportReal}`
+            : "escaped marker missing, so export-root escape was not reproduced"),
+        assertion("path_inside_sandbox", escapedExists && isInside(sandboxReal, escapedReal), escapedExists
+            ? `escaped marker stayed inside sandbox ${sandboxReal}`
+            : "escaped marker missing, so sandbox containment could not be proven"),
+        assertion("no_home_profile_touch", noHomeProfileTouch, noHomeProfileTouchDetail),
+    ];
+}
+function resultStatus(args) {
+    const required = new Set([
+        "filesystem_exists",
+        "filesystem_not_exists",
+        "path_outside_export_root",
+        "path_inside_sandbox",
+        "no_home_profile_touch",
+    ]);
+    const filesystemAssertions = args.assertions.filter((a) => required.has(a.kind));
+    if (filesystemAssertions.length > 0) {
+        if (filesystemAssertions.some((a) => a.kind === "filesystem_exists" && a.passed)) {
+            return "reproduced";
+        }
+        if (args.command.timedOut)
+            return "error";
+        if (args.command.error && args.command.exitCode === null)
+            return "error";
+        return "not_reproduced";
+    }
+    if (args.command.error && args.command.exitCode === null)
+        return "error";
+    if (args.command.timedOut)
+        return "error";
+    if (args.command.exitCode !== 0)
+        return "error";
+    return "inconclusive";
+}
+function summaryFor(status) {
+    switch (status) {
+        case "reproduced":
+            return "CLI path traversal replay wrote a marker outside the selected export directory inside the sandbox.";
+        case "not_reproduced":
+            return "CLI path traversal replay completed but did not write outside the selected export directory.";
+        case "inconclusive":
+            return "CLI path traversal replay was inconclusive.";
+        case "error":
+            return "CLI path traversal replay failed before reaching a reliable verdict.";
+    }
+}
+/**
+ * Run the deterministic CLI path traversal replay from 0#195.
+ *
+ * The fixture starts a malicious local API server and runs the caller-supplied
+ * CLI command against a sandboxed export directory. The harness itself never
+ * implements export behavior; the verdict comes from the CLI under test plus
+ * filesystem assertions over the sandbox.
+ */
+export async function runCliPathTraversalReplayFixture(options = {}) {
+    const startedAt = new Date().toISOString();
+    const fixtureMode = options.fixtureMode ?? "vulnerable";
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const retainArtifacts = options.retainArtifacts || Boolean(options.artifactDir);
+    const sandboxRoot = options.artifactDir
+        ? resolve(options.artifactDir)
+        : await mkdtemp(join(tmpdir(), "0-verify-"));
+    const exportDir = join(sandboxRoot, "export");
+    const harnessDir = join(sandboxRoot, "harness");
+    const harnessRef = join(harnessDir, "harness.json");
+    const stdoutRef = join(sandboxRoot, "stdout.log");
+    const stderrRef = join(sandboxRoot, "stderr.log");
+    const artifacts = {};
+    if (retainArtifacts) {
+        artifacts.sandbox_ref = sandboxRoot;
+        artifacts.harness_ref = harnessRef;
+        artifacts.stdout_ref = stdoutRef;
+        artifacts.stderr_ref = stderrRef;
+        artifacts.export_ref = exportDir;
+    }
+    let server;
+    let argv = [];
+    let command;
+    try {
+        await mkdir(exportDir, { recursive: true });
+        const fixture = await startMaliciousExportServer();
+        server = fixture.server;
+        if (!options.commandArgv || options.commandArgv.length === 0) {
+            throw new Error("cli-path-traversal fixture requires commandArgv for the real CLI under test");
+        }
+        argv = expandCommandArgv(options.commandArgv, {
+            apiUrl: fixture.baseUrl,
+            exportDir,
+            fixtureMode,
+        });
+        await mkdir(harnessDir, { recursive: true });
+        await writeFile(harnessRef, JSON.stringify({
+            fixture: "cli-path-traversal",
+            fixtureMode,
+            commandArgv: options.commandArgv,
+            expandedArgv: argv,
+            apiUrl: fixture.baseUrl,
+            exportDir,
+        }, null, 2) + "\n", "utf8");
+        command = await runCommand(argv, {
+            cwd: sandboxRoot,
+            timeoutMs,
+        });
+        await writeFile(stdoutRef, command.stdout, "utf8");
+        await writeFile(stderrRef, command.stderr, "utf8");
+        const assertions = await buildAssertions({
+            sandboxRoot,
+            exportDir,
+            escapedPath: join(sandboxRoot, "escaped-marker"),
+            insideExportPath: join(exportDir, "escaped-marker"),
+        });
+        if (command.exitCode !== 0 || command.error) {
+            assertions.unshift(assertion("command_exit_zero", false, command.error ?? `fixture command exited ${String(command.exitCode)}`));
+        }
+        else {
+            assertions.unshift(assertion("command_exit_zero", true, "fixture command exited 0"));
+        }
+        const status = resultStatus({ command, assertions });
+        return {
+            status,
+            mode: "deterministic_replay",
+            finding_id: FIXTURE_ID,
+            engine_version: options.engineVersion ?? "unknown",
+            started_at: startedAt,
+            completed_at: new Date().toISOString(),
+            commands: [
+                {
+                    argv,
+                    exit_code: command.exitCode,
+                    stdout_excerpt: excerpt(command.stdout),
+                    stderr_excerpt: excerpt(command.stderr),
+                },
+            ],
+            assertions,
+            artifacts,
+            summary: summaryFor(status),
+            error_reason: status === "error" ? command.error ?? "fixture command failed" : null,
+        };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        return {
+            status: "error",
+            mode: "deterministic_replay",
+            finding_id: FIXTURE_ID,
+            engine_version: options.engineVersion ?? "unknown",
+            started_at: startedAt,
+            completed_at: new Date().toISOString(),
+            commands: command
+                ? [
+                    {
+                        argv,
+                        exit_code: command.exitCode,
+                        stdout_excerpt: excerpt(command.stdout),
+                        stderr_excerpt: excerpt(command.stderr),
+                    },
+                ]
+                : [],
+            assertions: [],
+            artifacts,
+            summary: summaryFor("error"),
+            error_reason: reason,
+        };
+    }
+    finally {
+        if (server)
+            await closeServer(server);
+        if (!retainArtifacts) {
+            await rm(sandboxRoot, { recursive: true, force: true });
+        }
+    }
+}
+//# sourceMappingURL=cli-path-traversal-fixture.js.map

package/dashboard/assets/bot-Bg1Tp9_d.js

@@ -0,0 +1 @@
+import{_ as e}from"./input-TuVPR3Zl.js";var t=e(`bot`,[[`path`,{d:`M12 8V4H8`,key:`hb8ula`}],[`rect`,{width:`16`,height:`12`,x:`4`,y:`8`,rx:`2`,key:`enze0r`}],[`path`,{d:`M2 14h2`,key:`vft8re`}],[`path`,{d:`M20 14h2`,key:`4cs60a`}],[`path`,{d:`M15 13v2`,key:`1xurst`}],[`path`,{d:`M9 13v2`,key:`rq6x2g`}]]);export{t};

package/dashboard/assets/dist-B_dDCPbu.js

@@ -0,0 +1 @@
+import{f as e,m as t}from"./jsx-runtime-MGseXjj5.js";import{l as n}from"./format--susmHX7.js";import{i as r,l as i,m as a,n as o,p as s,s as c,t as l,v as u}from"./operations-BxZ0OoXO.js";var d=class extends u{#e;#t=void 0;#n;#r;constructor(e,t){super(),this.#e=e,this.setOptions(t),this.bindMethods(),this.#i()}bindMethods(){this.mutate=this.mutate.bind(this),this.reset=this.reset.bind(this)}setOptions(e){let t=this.options;this.options=this.#e.defaultMutationOptions(e),s(this.options,t)||this.#e.getMutationCache().notify({type:`observerOptionsUpdated`,mutation:this.#n,observer:this}),t?.mutationKey&&this.options.mutationKey&&c(t.mutationKey)!==c(this.options.mutationKey)?this.reset():this.#n?.state.status===`pending`&&this.#n.setOptions(this.options)}onUnsubscribe(){this.hasListeners()||this.#n?.removeObserver(this)}onMutationUpdate(e){this.#i(),this.#a(e)}getCurrentResult(){return this.#t}reset(){this.#n?.removeObserver(this),this.#n=void 0,this.#i(),this.#a()}mutate(e,t){return this.#r=t,this.#n?.removeObserver(this),this.#n=this.#e.getMutationCache().build(this.#e,this.options),this.#n.addObserver(this),this.#n.execute(e)}#i(){let e=this.#n?.state??o();this.#t={...e,isPending:e.status===`pending`,isSuccess:e.status===`success`,isError:e.status===`error`,isIdle:e.status===`idle`,mutate:this.mutate,reset:this.reset}}#a(e){r.batch(()=>{if(this.#r&&this.hasListeners()){let t=this.#t.variables,n=this.#t.context,r={client:this.#e,meta:this.options.meta,mutationKey:this.options.mutationKey};if(e?.type===`success`){try{this.#r.onSuccess?.(e.data,t,n,r)}catch(e){Promise.reject(e)}try{this.#r.onSettled?.(e.data,null,t,n,r)}catch(e){Promise.reject(e)}}else if(e?.type===`error`){try{this.#r.onError?.(e.error,t,n,r)}catch(e){Promise.reject(e)}try{this.#r.onSettled?.(void 0,e.error,t,n,r)}catch(e){Promise.reject(e)}}}this.listeners.forEach(e=>{e(this.#t)})})}},f=t(e(),1);function p(e,t){let n=l(t),[o]=f.useState(()=>new d(n,e));f.useEffect(()=>{o.setOptions(e)},[o,e]);let s=f.useSyncExternalStore(f.useCallback(e=>o.subscribe(r.batchCalls(e)),[o]),()=>o.getCurrentResult(),()=>o.getCurrentResult()),c=f.useCallback((e,t)=>{o.mutate(e,t).catch(i)},[o]);if(s.error&&a(o.options.throwOnError,[s.error]))throw s.error;return{...s,mutate:c,mutateAsync:s.mutate}}var m=f.useId||(()=>void 0),h=0;function g(e){let[t,r]=f.useState(m());return n(()=>{e||r(e=>e??String(h++))},[e]),e||(t?`radix-${t}`:``)}var _=f.useInsertionEffect||n;function v({prop:e,defaultProp:t,onChange:n=()=>{},caller:r}){let[i,a,o]=y({defaultProp:t,onChange:n}),s=e!==void 0,c=s?e:i;{let t=f.useRef(e!==void 0);f.useEffect(()=>{let e=t.current;e!==s&&console.warn(`${r} is changing from ${e?`controlled`:`uncontrolled`} to ${s?`controlled`:`uncontrolled`}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`),t.current=s},[s,r])}return[c,f.useCallback(t=>{if(s){let n=b(t)?t(e):t;n!==e&&o.current?.(n)}else a(t)},[s,e,a,o])]}function y({defaultProp:e,onChange:t}){let[n,r]=f.useState(e),i=f.useRef(n),a=f.useRef(t);return _(()=>{a.current=t},[t]),f.useEffect(()=>{i.current!==n&&(a.current?.(n),i.current=n)},[n,i]),[n,r,a]}function b(e){return typeof e==`function`}export{g as n,p as r,v as t};