@paybond/kit 0.9.7 → 0.10.0

package/dist/cli/ux.js

@@ -0,0 +1,164 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { COMMAND_EXAMPLES, COMPLETION_SCRIPTS, WORKFLOWS } from "./command-spec.js";
+import { resolvedDefaultsForDoctor } from "./credentials.js";
+import { helpForCommand } from "./help.js";
+import { consumeFlag } from "./globals.js";
+import { planMcpInstall, parseMcpInstallFormat, parseMcpInstallHost, parseMcpInstallScope } from "./mcp-install.js";
+import { CliError } from "./types.js";
+import { handleDoctor } from "./commands/setup.js";
+export function resolveHelpPath(argv) {
+    return argv.filter((part) => part !== "--help" && part !== "-h").join(" ");
+}
+export function renderHelpText(path) {
+    return helpForCommand(path);
+}
+export function handleHelpCommand(argv) {
+    const helpPath = resolveHelpPath(argv);
+    return { data: { text: renderHelpText(helpPath), path: helpPath || "paybond" } };
+}
+export function handleExamplesCommand(argv) {
+    const filterPath = argv.filter((part) => part !== "--help" && part !== "-h").join(" ");
+    const lines = [];
+    if (!filterPath) {
+        lines.push("Workflows:");
+        for (const workflow of WORKFLOWS) {
+            lines.push("", workflow.title);
+            if (workflow.description) {
+                lines.push(workflow.description);
+            }
+            for (const example of workflow.examples) {
+                lines.push(`  $ ${example}`);
+            }
+            if (workflow.next) {
+                lines.push(`  Next: ${workflow.next}`);
+            }
+        }
+        lines.push("", "Commands:");
+    }
+    const entries = filterPath
+        ? Object.entries(COMMAND_EXAMPLES).filter(([commandPath]) => commandPath === filterPath || commandPath.startsWith(`${filterPath} `))
+        : Object.entries(COMMAND_EXAMPLES);
+    if (filterPath && entries.length === 0) {
+        throw new CliError(`no examples found for: ${filterPath}`, {
+            category: "usage",
+            code: "cli.usage.unknown_command",
+        });
+    }
+    for (const [commandPath, examples] of entries) {
+        lines.push("", `paybond ${commandPath}`);
+        for (const example of examples) {
+            lines.push(`  $ ${example}`);
+        }
+    }
+    return { data: { text: lines.join("\n").trim(), filter: filterPath || null, count: entries.length } };
+}
+export function handleCompletionCommand(argv) {
+    const shell = argv[0];
+    if (!shell || shell === "--help" || shell === "-h") {
+        throw new CliError("completion requires bash|zsh|fish", {
+            category: "usage",
+            code: "cli.usage.missing_completion_shell",
+        });
+    }
+    const script = COMPLETION_SCRIPTS[shell];
+    if (!script) {
+        throw new CliError(`unsupported completion shell: ${shell} (expected bash|zsh|fish)`, {
+            category: "usage",
+            code: "cli.usage.invalid_completion_shell",
+        });
+    }
+    return { data: { shell, script } };
+}
+export async function handleOnboarding(ctx, argv) {
+    const hostFlag = consumeFlag(argv, "--host");
+    let installHost = "generic";
+    try {
+        if (hostFlag.present) {
+            installHost = parseMcpInstallHost(hostFlag.value);
+        }
+    }
+    catch (err) {
+        throw new CliError(err instanceof Error ? err.message : String(err), {
+            category: "usage",
+            code: "cli.usage.invalid_mcp_install",
+        });
+    }
+    const steps = [];
+    steps.push({
+        name: "runtime",
+        ok: true,
+        message: `node ${process.version}`,
+    });
+    const defaults = resolvedDefaultsForDoctor(ctx.globals);
+    const envPath = path.isAbsolute(defaults.envFile)
+        ? path.resolve(defaults.envFile)
+        : path.resolve(ctx.cwd, defaults.envFile);
+    let loggedIn = false;
+    try {
+        const { resolveApiKey } = await import("./credentials.js");
+        const apiKey = await resolveApiKey(ctx.globals, ctx.cwd);
+        loggedIn = true;
+        const { maskApiKey } = await import("./redact.js");
+        steps.push({
+            name: "login",
+            ok: true,
+            message: `credentials found (${maskApiKey(apiKey)})`,
+        });
+    }
+    catch (err) {
+        steps.push({
+            name: "login",
+            ok: false,
+            message: err instanceof Error ? err.message : String(err),
+            command: "paybond login",
+        });
+    }
+    const guardrailPath = path.resolve(ctx.cwd, "paybond-paid-tool-guard.ts");
+    let guardrailExists = false;
+    try {
+        await access(guardrailPath);
+        guardrailExists = true;
+    }
+    catch {
+        guardrailExists = false;
+    }
+    steps.push({
+        name: "guardrail",
+        ok: guardrailExists,
+        message: guardrailExists ? `found ${guardrailPath}` : `guardrail file not found (${guardrailPath})`,
+        command: guardrailExists ? undefined : "paybond init guardrail",
+    });
+    const plan = planMcpInstall({
+        host: installHost,
+        scope: parseMcpInstallScope("local"),
+        format: parseMcpInstallFormat(undefined, installHost),
+        envFile: defaults.envFile,
+        cwd: ctx.cwd,
+        home: process.env.HOME ?? process.env.USERPROFILE ?? ctx.cwd,
+    });
+    steps.push({
+        name: "mcp_config",
+        ok: true,
+        message: `preview ready for host=${plan.host} (non-destructive --scope local)`,
+        command: `paybond mcp install --host ${plan.host} --scope local`,
+    });
+    const doctor = await handleDoctor(ctx, loggedIn ? ["--agent"] : []);
+    const doctorOk = String(doctor.data.summary) === "pass";
+    steps.push({
+        name: "doctor",
+        ok: doctorOk,
+        message: `doctor ${doctor.data.summary}`,
+        command: doctorOk ? undefined : "paybond doctor --agent",
+    });
+    const summary = steps.every((step) => step.ok) ? "pass" : "fail";
+    return {
+        data: {
+            steps,
+            summary,
+            env_file: envPath,
+            mcp_preview: plan.printed ? plan.payload : undefined,
+            doctor_checks: doctor.data.checks,
+        },
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export { runCli } from "./cli/router.js";

package/dist/cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { runCli } from "./cli/router.js";
+async function invokedFromCLI() {
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        return false;
+    }
+    async function realFileURL(filePath) {
+        let resolved = path.resolve(filePath);
+        try {
+            resolved = await fs.realpath(resolved);
+        }
+        catch {
+            // keep absolute path
+        }
+        const href = pathToFileURL(resolved).href;
+        return href.startsWith("file:///var/") ? href.replace("file:///var/", "file:///private/var/") : href;
+    }
+    return (await realFileURL(scriptPath)) === (await realFileURL(fileURLToPath(import.meta.url)));
+}
+invokedFromCLI().then((invoked) => {
+    if (!invoked) {
+        return;
+    }
+    runCli(process.argv.slice(2)).then((code) => {
+        process.exitCode = code;
+    }, (err) => {
+        process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+        process.exitCode = 1;
+    });
+}, (err) => {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    process.exitCode = 1;
+});
+export { runCli } from "./cli/router.js";

package/dist/index.d.ts

@@ -4,6 +4,10 @@
  */
 import { type BuildSignedCreateIntentParams, type SettlementRail } from "./principal-intent.js";
 import { type SignPayeeEvidenceParams } from "./payee-evidence.js";
+export type SpendScope = {
+    scope_type: string;
+    scope_key: string;
+};
 export type VerifyCapabilityResult = {
     allow: boolean;
     auditId: string;
@@ -11,6 +15,28 @@ export type VerifyCapabilityResult = {
     intentId: string;
     code?: string;
     message?: string;
+    decisionId?: string;
+    approvalRequestId?: string;
+    policyVersion?: number;
+    reasonCodes?: string[];
+    spendScope?: SpendScope;
+    remainingCents?: number;
+    retryAfter?: number;
+    /** True when gateway policy requires operator approval before execution may proceed. */
+    approvalRequired?: boolean;
+};
+export type PaybondSpendAuthorizationInput = {
+    operation: string;
+    requestedSpendCents?: number;
+    vendorId?: string;
+    taskId?: string;
+    workflowId?: string;
+    toolCallId?: string;
+    toolName?: string;
+    currency?: string;
+    agentSubject?: string;
+    approvalToken?: string;
+    idempotencyKey?: string;
 };
 export type SubmitEvidenceResult = {
     intentId: string;
@@ -715,14 +741,19 @@ export declare class PaybondCapabilityBinding {
     authorizeSpend(input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
 }
 export type PaybondSpendGuardInit = {
-    harbor: Pick<HarborClient | GatewayHarborClient, "tenantId" | "verifyCapability">;
+    harbor: Pick<HarborClient | GatewayHarborClient, "tenantId" | "verifyCapability"> & {
+        completeSpendDecision?: (input: {
+            decisionId: string;
+            outcome: "consumed" | "released";
+        }) => Promise<void>;
+    };
     intentId: string;
     capabilityToken: string;
 };
-export type PaybondSpendAuthorizationInput = {
-    operation: string;
-    requestedSpendCents?: number;
-};
+export declare class PaybondSpendApprovalRequiredError extends Error {
+    readonly result: VerifyCapabilityResult;
+    constructor(result: VerifyCapabilityResult);
+}
 export declare class PaybondSpendDeniedError extends Error {
     readonly result: VerifyCapabilityResult;
     constructor(result: VerifyCapabilityResult);
@@ -730,13 +761,15 @@ export declare class PaybondSpendDeniedError extends Error {
 export type PaybondToolHandler<TArgs extends unknown[], TResult> = (...args: TArgs) => TResult | Promise<TResult>;
 export type PaybondGuardedToolHandler<TArgs extends unknown[], TResult> = (...args: TArgs) => Promise<Awaited<TResult>>;
 export declare class PaybondSpendGuard {
-    readonly harbor: Pick<HarborClient | GatewayHarborClient, "tenantId" | "verifyCapability">;
+    readonly harbor: PaybondSpendGuardInit["harbor"];
     readonly intentId: string;
     readonly capabilityToken: string;
     constructor(init: PaybondSpendGuardInit | PaybondCapabilityBinding);
     verifySpendCapability(input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
     authorizeSpend(input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
     assertSpendAuthorized(input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
+    /** Finalizes scope reservations tied to an authorization decision after tool execution. */
+    completeSpendAuthorization(decisionId: string, outcome: "consumed" | "released"): Promise<void>;
     guardTool<TArgs extends unknown[], TResult>(input: PaybondSpendAuthorizationInput, handler: PaybondToolHandler<TArgs, TResult>): PaybondGuardedToolHandler<TArgs, TResult>;
 }
 export declare function authorizeSpend(source: PaybondSpendGuardInit | PaybondCapabilityBinding, input: PaybondSpendAuthorizationInput): Promise<VerifyCapabilityResult>;
@@ -799,11 +832,9 @@ export declare class HarborClient {
      * @throws HarborHttpError when HTTP fails
      * @throws Error when Harbor echoes a different tenant / intent than requested
      */
-    verifyCapability(input: {
+    verifyCapability(input: PaybondSpendAuthorizationInput & {
         intentId: string;
         token: string;
-        operation: string;
-        requestedSpendCents?: number;
     }): Promise<VerifyCapabilityResult>;
     verifySpendCapability(input: {
         intentId: string;
@@ -897,11 +928,9 @@ export declare class GatewayHarborClient {
     private fetchWithRetries;
     private postJSON;
     private mutationHeaders;
-    verifyCapability(input: {
+    verifyCapability(input: PaybondSpendAuthorizationInput & {
         intentId: string;
         token: string;
-        operation: string;
-        requestedSpendCents?: number;
     }): Promise<VerifyCapabilityResult>;
     verifySpendCapability(input: {
         intentId: string;
@@ -915,6 +944,11 @@ export declare class GatewayHarborClient {
         operation: string;
         requestedSpendCents?: number;
     }): Promise<VerifyCapabilityResult>;
+    /** Finalizes active spend reservations after tool execution completes or is aborted. */
+    completeSpendDecision(input: {
+        decisionId: string;
+        outcome: "consumed" | "released";
+    }): Promise<void>;
     createIntent(body: Record<string, unknown>, options: GatewayHarborMutationOptions): Promise<Record<string, unknown>>;
     fundIntent(intentId: string, options: GatewayHarborMutationOptions & {
         paymentSignature?: string;

package/dist/index.js

@@ -4,6 +4,77 @@
  */
 import { buildSignedCreateIntentBody, } from "./principal-intent.js";
 import { signPayeeEvidenceBinding } from "./payee-evidence.js";
+function parseVerifyCapabilityBody(body, expectedTenant, expectedIntentId) {
+    const tenant = String(body.tenant ?? "");
+    const intentId = String(body.intent_id ?? "");
+    if (tenant !== expectedTenant) {
+        throw new Error(`verify tenant mismatch: client=${expectedTenant} remote=${tenant}`);
+    }
+    if (intentId !== expectedIntentId) {
+        throw new Error(`verify intent mismatch: requested=${expectedIntentId} remote=${intentId}`);
+    }
+    const reasonCodes = Array.isArray(body.reason_codes)
+        ? body.reason_codes.map((value) => String(value))
+        : undefined;
+    const spendScope = body.spend_scope && typeof body.spend_scope === "object" && !Array.isArray(body.spend_scope)
+        ? {
+            scope_type: String(body.spend_scope.scope_type ?? ""),
+            scope_key: String(body.spend_scope.scope_key ?? ""),
+        }
+        : undefined;
+    const code = body.code != null ? String(body.code) : undefined;
+    const approvalRequired = code === "approval_required" ||
+        reasonCodes?.includes("approval_threshold_exceeded") ||
+        reasonCodes?.includes("approval_required_pending") ||
+        reasonCodes?.includes("anomaly_new_vendor") ||
+        reasonCodes?.includes("anomaly_amount_spike") ||
+        reasonCodes?.includes("anomaly_rapid_auth") ||
+        reasonCodes?.includes("anomaly_cap_proximity") ||
+        false;
+    return {
+        allow: Boolean(body.allow),
+        auditId: String(body.audit_id ?? ""),
+        tenant,
+        intentId,
+        code,
+        message: body.message != null ? String(body.message) : undefined,
+        decisionId: body.decision_id != null ? String(body.decision_id) : undefined,
+        approvalRequestId: body.approval_request_id != null ? String(body.approval_request_id) : undefined,
+        policyVersion: typeof body.policy_version === "number" ? body.policy_version : undefined,
+        reasonCodes,
+        spendScope,
+        remainingCents: typeof body.remaining_cents === "number" ? body.remaining_cents : undefined,
+        retryAfter: typeof body.retry_after === "number" ? body.retry_after : undefined,
+        approvalRequired,
+    };
+}
+function verifyCapabilityPayload(input) {
+    const payload = {
+        intent_id: input.intentId,
+        token: input.token,
+        operation: input.operation,
+        requested_spend_cents: input.requestedSpendCents ?? 0,
+    };
+    if (input.vendorId?.trim())
+        payload.vendor_id = input.vendorId.trim();
+    if (input.taskId?.trim())
+        payload.task_id = input.taskId.trim();
+    if (input.workflowId?.trim())
+        payload.workflow_id = input.workflowId.trim();
+    if (input.toolCallId?.trim())
+        payload.tool_call_id = input.toolCallId.trim();
+    if (input.toolName?.trim())
+        payload.tool_name = input.toolName.trim();
+    if (input.currency?.trim())
+        payload.currency = input.currency.trim();
+    if (input.agentSubject?.trim())
+        payload.agent_subject = input.agentSubject.trim();
+    if (input.approvalToken?.trim())
+        payload.approval_token = input.approvalToken.trim();
+    if (input.idempotencyKey?.trim())
+        payload.idempotency_key = input.idempotencyKey.trim();
+    return payload;
+}
 export const DEFAULT_PAYBOND_GATEWAY_BASE_URL = "https://api.paybond.ai";
 function defaultGatewayBaseUrl(value) {
     const trimmed = value?.trim();
@@ -158,16 +229,24 @@ export class PaybondCapabilityBinding {
     }
     async verifySpendCapability(input) {
         return this.harbor.verifyCapability({
+            ...input,
             intentId: this.intentId,
             token: this.capabilityToken,
-            operation: input.operation,
-            requestedSpendCents: input.requestedSpendCents,
         });
     }
     async authorizeSpend(input) {
         return this.verifySpendCapability(input);
     }
 }
+export class PaybondSpendApprovalRequiredError extends Error {
+    result;
+    constructor(result) {
+        const reason = result.message ?? result.code ?? "approval_required";
+        super(`Paybond spend authorization requires approval: ${reason}`);
+        this.name = "PaybondSpendApprovalRequiredError";
+        this.result = result;
+    }
+}
 export class PaybondSpendDeniedError extends Error {
     result;
     constructor(result) {
@@ -188,10 +267,9 @@ export class PaybondSpendGuard {
     }
     async verifySpendCapability(input) {
         return this.harbor.verifyCapability({
+            ...input,
             intentId: this.intentId,
             token: this.capabilityToken,
-            operation: input.operation,
-            requestedSpendCents: input.requestedSpendCents,
         });
     }
     async authorizeSpend(input) {
@@ -200,14 +278,42 @@ export class PaybondSpendGuard {
     async assertSpendAuthorized(input) {
         const result = await this.authorizeSpend(input);
         if (!result.allow) {
+            if (result.approvalRequired) {
+                throw new PaybondSpendApprovalRequiredError(result);
+            }
             throw new PaybondSpendDeniedError(result);
         }
         return result;
     }
+    /** Finalizes scope reservations tied to an authorization decision after tool execution. */
+    async completeSpendAuthorization(decisionId, outcome) {
+        const complete = this.harbor.completeSpendDecision;
+        if (!complete) {
+            return;
+        }
+        await complete.call(this.harbor, { decisionId, outcome });
+    }
     guardTool(input, handler) {
         return async (...args) => {
-            await this.assertSpendAuthorized(input);
-            return await handler(...args);
+            const auth = await this.assertSpendAuthorized(input);
+            try {
+                const result = await handler(...args);
+                if (auth.decisionId) {
+                    await this.completeSpendAuthorization(auth.decisionId, "consumed");
+                }
+                return result;
+            }
+            catch (err) {
+                if (auth.decisionId) {
+                    try {
+                        await this.completeSpendAuthorization(auth.decisionId, "released");
+                    }
+                    catch {
+                        // Best-effort release when the guarded handler fails.
+                    }
+                }
+                throw err;
+            }
         };
     }
 }
@@ -245,6 +351,9 @@ export function paybondRuntimeToolCallAdapter(init) {
             if (init.onDeny) {
                 return await init.onDeny(result, call);
             }
+            if (result.approvalRequired) {
+                throw new PaybondSpendApprovalRequiredError(result);
+            }
             throw new PaybondSpendDeniedError(result);
         }
         return await init.execute(call);
@@ -384,17 +493,13 @@ export class HarborClient {
      */
     async verifyCapability(input) {
         const url = `${this.base}verify`;
-        const payload = {
-            intent_id: input.intentId,
-            token: input.token,
-            operation: input.operation,
-            requested_spend_cents: input.requestedSpendCents ?? 0,
-        };
+        const payload = verifyCapabilityPayload(input);
         const res = await this.fetchWithRetries(url, {
             method: "POST",
             headers: {
                 "content-type": "application/json",
                 "x-tenant-id": this.tenantId,
+                ...(input.idempotencyKey?.trim() ? { "idempotency-key": input.idempotencyKey.trim() } : {}),
             },
             body: JSON.stringify(payload),
         }, { retryBody: payload });
@@ -407,20 +512,7 @@ export class HarborClient {
             });
         }
         const body = JSON.parse(text);
-        if (body.tenant !== this.tenantId) {
-            throw new Error(`verify tenant mismatch: client=${this.tenantId} harbor=${body.tenant}`);
-        }
-        if (body.intent_id !== input.intentId) {
-            throw new Error(`verify intent mismatch: requested=${input.intentId} harbor=${body.intent_id}`);
-        }
-        return {
-            allow: body.allow,
-            auditId: body.audit_id,
-            tenant: body.tenant,
-            intentId: body.intent_id,
-            code: body.code,
-            message: body.message,
-        };
+        return parseVerifyCapabilityBody(body, this.tenantId, input.intentId);
     }
     async verifySpendCapability(input) {
         return this.verifyCapability(input);
@@ -722,13 +814,12 @@ export class GatewayHarborClient {
         });
     }
     async verifyCapability(input) {
-        const payload = {
-            intent_id: input.intentId,
-            token: input.token,
-            operation: input.operation,
-            requested_spend_cents: input.requestedSpendCents ?? 0,
-        };
-        const { res, text, url } = await this.postJSON("/verify", payload);
+        const payload = verifyCapabilityPayload(input);
+        const headers = {};
+        if (input.idempotencyKey?.trim()) {
+            headers["idempotency-key"] = input.idempotencyKey.trim();
+        }
+        const { res, text, url } = await this.postJSON("/verify", payload, headers);
         if (!res.ok) {
             throw new HarborHttpError(`Gateway verify HTTP ${res.status}: ${text}`, {
                 statusCode: res.status,
@@ -737,20 +828,7 @@ export class GatewayHarborClient {
             });
         }
         const body = JSON.parse(text);
-        if (body.tenant !== this.tenantId) {
-            throw new Error(`verify tenant mismatch: client=${this.tenantId} gateway=${body.tenant}`);
-        }
-        if (body.intent_id !== input.intentId) {
-            throw new Error(`verify intent mismatch: requested=${input.intentId} gateway=${body.intent_id}`);
-        }
-        return {
-            allow: body.allow,
-            auditId: body.audit_id,
-            tenant: body.tenant,
-            intentId: body.intent_id,
-            code: body.code,
-            message: body.message,
-        };
+        return parseVerifyCapabilityBody(body, this.tenantId, input.intentId);
     }
     async verifySpendCapability(input) {
         return this.verifyCapability(input);
@@ -758,6 +836,17 @@ export class GatewayHarborClient {
     async authorizeSpend(input) {
         return this.verifyCapability(input);
     }
+    /** Finalizes active spend reservations after tool execution completes or is aborted. */
+    async completeSpendDecision(input) {
+        const { res, text, url } = await this.postJSON(`/v1/spend/decisions/${encodeURIComponent(input.decisionId)}/complete`, { outcome: input.outcome });
+        if (!res.ok) {
+            throw new HarborHttpError(`Gateway spend complete HTTP ${res.status}: ${text}`, {
+                statusCode: res.status,
+                url,
+                bodyText: text,
+            });
+        }
+    }
     async createIntent(body, options) {
         const { res, text, url } = await this.postJSON("/harbor/intents", body, this.mutationHeaders("createIntent", options));
         if (!res.ok) {

package/dist/init.js

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { runCli } from "./cli/router.js";
 const FRAMEWORKS = new Set([
     "generic",
     "provider-agnostic",
@@ -79,7 +83,8 @@ function parseArgs(argv) {
     return { preset, framework, out, force };
 }
 function template(framework) {
-    return `import {
+    return `import fs from "node:fs/promises";
+import {
   Paybond,
   type SandboxGuardrailBootstrapResult,
   type SandboxGuardrailEvidenceResult,
@@ -139,8 +144,6 @@ function readEnvValue(body: string, key: string): string | undefined {
 }
 
 async function readTextFile(envFile: string): Promise<string | undefined> {
-  // @ts-ignore Node builtins are available in agent and CLI Node runtimes.
-  const fs: { readFile(path: string, encoding: "utf8"): Promise<string> } = await import("node:fs/promises");
   try {
     return await fs.readFile(envFile, "utf8");
   } catch (err) {
@@ -239,8 +242,6 @@ export async function submitSandboxEvidence(
 `;
 }
 async function writeScaffold(out, body, force) {
-    // @ts-expect-error Node builtins are available in the published CLI runtime.
-    const fs = await import("node:fs/promises");
     try {
         await fs.stat(out);
         if (!force) {
@@ -286,12 +287,6 @@ async function invokedFromCLI() {
     if (!scriptPath) {
         return false;
     }
-    // @ts-ignore Node builtins are available in the published CLI runtime.
-    const fs = (await import("node:fs/promises"));
-    // @ts-ignore Node builtins are available in the published CLI runtime.
-    const path = (await import("node:path"));
-    // @ts-ignore Node builtins are available in the published CLI runtime.
-    const url = (await import("node:url"));
     async function realFileURL(filePath) {
         let resolved = path.resolve(filePath);
         try {
@@ -301,15 +296,15 @@ async function invokedFromCLI() {
             // If realpath fails, compare the absolute path. This keeps direct execution
             // working even when the script path disappears during process startup.
         }
-        return normalizeFileURL(url.pathToFileURL(resolved).href);
+        return normalizeFileURL(pathToFileURL(resolved).href);
     }
-    return (await realFileURL(scriptPath)) === (await realFileURL(url.fileURLToPath(import.meta.url)));
+    return (await realFileURL(scriptPath)) === (await realFileURL(fileURLToPath(import.meta.url)));
 }
 invokedFromCLI().then((invoked) => {
     if (!invoked) {
         return;
     }
-    main().then((code) => {
+    runCli(["init", "guardrail", ...process.argv.slice(2)]).then((code) => {
         process.exitCode = code;
     }, (err) => {
         process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);