@creativeintelligence/abbie 0.1.0

package/dist/cli/commands/tunnel/list.js

@@ -0,0 +1,98 @@
+import { Flags } from "@oclif/core";
+import { createNgrokManager, getAgentStatus, isAgentRunning } from "../../../lib/ngrok.js";
+import { BaseCommand } from "../../base-command.js";
+export default class TunnelList extends BaseCommand {
+    static description = "List active ngrok tunnels";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> tunnel list",
+        "<%= config.bin %> tunnel list --json",
+        "<%= config.bin %> tunnel list --urls",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        urls: Flags.boolean({
+            char: "u",
+            description: "Output only URLs (one per line)",
+            default: false,
+        }),
+        status: Flags.boolean({
+            description: "Include agent status",
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(TunnelList);
+        this.parsedFlags = flags;
+        const ngrok = createNgrokManager();
+        // Cleanup stale metadata
+        await ngrok.cleanup();
+        // Check if agent is running
+        const running = await isAgentRunning();
+        if (!running) {
+            if (flags.json || flags.format === "json") {
+                return { agent_running: false, tunnels: [] };
+            }
+            if (flags.urls) {
+                return { tunnels: [] };
+            }
+            this.logInfo("ngrok agent not running");
+            return { tunnels: [] };
+        }
+        const tunnels = await ngrok.list();
+        const agentStatus = flags.status ? await getAgentStatus() : undefined;
+        if (flags.json || flags.format === "json") {
+            return {
+                agent_running: true,
+                agent_status: agentStatus,
+                tunnels: tunnels.map((t) => ({
+                    name: t.name,
+                    public_url: t.public_url,
+                    port: t.config?.addr,
+                    session_id: t.metadata?.session_id,
+                    created_at: t.metadata?.created_at,
+                })),
+            };
+        }
+        // NDJSON: one tunnel per line
+        if (this.ndjsonEnabled()) {
+            const items = tunnels.map((t) => ({
+                name: t.name,
+                public_url: t.public_url,
+                port: t.config?.addr,
+                session_id: t.metadata?.session_id,
+                created_at: t.metadata?.created_at,
+            }));
+            this.outputNdjson(items);
+            return { tunnels };
+        }
+        // URLs only (for piping)
+        if (flags.urls) {
+            for (const tunnel of tunnels) {
+                this.log(tunnel.public_url);
+            }
+            return { tunnels };
+        }
+        // Human-readable format
+        if (tunnels.length === 0) {
+            this.logInfo("No active tunnels");
+            return { tunnels: [] };
+        }
+        this.log("");
+        if (agentStatus) {
+            this.log(`Agent: v${agentStatus.version} (${agentStatus.region})`);
+            this.log("");
+        }
+        for (const tunnel of tunnels) {
+            this.log(`${tunnel.name}`);
+            this.log(`  url:     ${tunnel.public_url}`);
+            this.log(`  port:    ${tunnel.config?.addr || "unknown"}`);
+            if (tunnel.metadata) {
+                this.log(`  session: ${tunnel.metadata.session_id}`);
+                this.log(`  created: ${tunnel.metadata.created_at}`);
+            }
+            this.log("");
+        }
+        return { tunnels };
+    }
+}

package/dist/cli/commands/tunnel/start.d.ts

@@ -0,0 +1,24 @@
+import { BaseCommand } from "../../base-command.js";
+export default class TunnelStart extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static args: {
+        port: import("@oclif/core/interfaces").Arg<number | undefined, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static flags: {
+        session: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "skip-resource": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected execute(): Promise<unknown>;
+    private tryReadStdin;
+}
+//# sourceMappingURL=start.d.ts.map

package/dist/cli/commands/tunnel/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/tunnel/start.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,WAAY,SAAQ,WAAW;IAClD,OAAgB,WAAW,SAA4C;IACvE,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAKtB;IAEF,OAAgB,IAAI;;;;;MAIlB;IAEF,OAAgB,KAAK;;;;;;;;MAcnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;YAmE7B,YAAY;CAgB3B"}

package/dist/cli/commands/tunnel/start.js

@@ -0,0 +1,107 @@
+import { Args, Flags } from "@oclif/core";
+import { createNgrokManager, ensureAgentRunning } from "../../../lib/ngrok.js";
+import { createResourceManager } from "../../../lib/resources.js";
+import { BaseCommand } from "../../base-command.js";
+export default class TunnelStart extends BaseCommand {
+    static description = "Start an ngrok tunnel for a local port";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> tunnel start 3000",
+        "<%= config.bin %> tunnel start 3000 --session SESSION_ID",
+        "<%= config.bin %> tunnel start 8080 --name myapp --json",
+        "echo 3000 | <%= config.bin %> tunnel start",
+    ];
+    static args = {
+        port: Args.integer({
+            description: "Local port to tunnel",
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        session: Flags.string({
+            char: "s",
+            description: "Session ID for resource tracking",
+        }),
+        name: Flags.string({
+            char: "n",
+            description: "Tunnel name",
+        }),
+        "skip-resource": Flags.boolean({
+            description: "Skip resource semaphore acquisition",
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TunnelStart);
+        this.parsedFlags = flags;
+        // Support stdin for port
+        let port = args.port;
+        if (!port) {
+            // Read from stdin if available
+            const stdin = await this.tryReadStdin();
+            if (stdin) {
+                port = parseInt(stdin.trim(), 10);
+            }
+        }
+        if (!port || Number.isNaN(port)) {
+            this.error("Port is required. Provide as argument or via stdin.");
+        }
+        const sessionId = flags.session || `tunnel-${Date.now().toString(36)}`;
+        // Acquire ngrok resource slot (unless skipped)
+        if (!flags["skip-resource"]) {
+            const resources = createResourceManager();
+            const lease = resources.acquire("ngrok_tunnel", sessionId, "system");
+            if (!lease) {
+                if (flags.json || flags.format === "json") {
+                    return { success: false, reason: "No ngrok slots available" };
+                }
+                this.error("No ngrok slots available. Use --skip-resource to bypass.");
+            }
+        }
+        // Ensure agent is running
+        if (!(await ensureAgentRunning())) {
+            if (flags.json || flags.format === "json") {
+                return { success: false, reason: "Failed to start ngrok agent" };
+            }
+            this.error("Failed to start ngrok agent");
+        }
+        const ngrok = createNgrokManager();
+        const result = await ngrok.start(port, sessionId, flags.name);
+        if (!result) {
+            if (flags.json || flags.format === "json") {
+                return { success: false, reason: "Failed to create tunnel" };
+            }
+            this.error("Failed to create tunnel");
+        }
+        if (flags.json || flags.format === "json") {
+            return {
+                success: true,
+                tunnel: {
+                    name: result.tunnel.name,
+                    public_url: result.public_url,
+                    port,
+                    session_id: sessionId,
+                },
+            };
+        }
+        // Unix pipe output: just the URL
+        this.log(result.public_url);
+        return { success: true, public_url: result.public_url };
+    }
+    async tryReadStdin() {
+        if (process.stdin.isTTY)
+            return undefined;
+        return new Promise((resolve) => {
+            let data = "";
+            process.stdin.setEncoding("utf8");
+            process.stdin.on("data", (chunk) => {
+                data += chunk;
+            });
+            process.stdin.on("end", () => {
+                resolve(data || undefined);
+            });
+            // Timeout after 100ms if no stdin
+            setTimeout(() => resolve(data || undefined), 100);
+        });
+    }
+}

package/dist/cli/commands/tunnel/stop.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from "../../base-command.js";
+export default class TunnelStop extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        session: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        kill: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected execute(): Promise<unknown>;
+}
+//# sourceMappingURL=stop.d.ts.map

package/dist/cli/commands/tunnel/stop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/tunnel/stop.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,WAAW;IACjD,OAAgB,WAAW,SAAwB;IACnD,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAKtB;IAEF,OAAgB,IAAI;;MAIlB;IAEF,OAAgB,KAAK;;;;;;;;MAenB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CAoE5C"}

package/dist/cli/commands/tunnel/stop.js

@@ -0,0 +1,90 @@
+import { Args, Flags } from "@oclif/core";
+import { createNgrokManager, killNgrok, listTunnels, stopTunnel } from "../../../lib/ngrok.js";
+import { createResourceManager } from "../../../lib/resources.js";
+import { BaseCommand } from "../../base-command.js";
+export default class TunnelStop extends BaseCommand {
+    static description = "Stop ngrok tunnels";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> tunnel stop myapp",
+        "<%= config.bin %> tunnel stop --session SESSION_ID",
+        "<%= config.bin %> tunnel stop --all",
+        "<%= config.bin %> tunnel stop --kill",
+    ];
+    static args = {
+        name: Args.string({
+            description: "Tunnel name to stop",
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+        session: Flags.string({
+            char: "s",
+            description: "Stop all tunnels for a session",
+        }),
+        all: Flags.boolean({
+            description: "Stop all tunnels",
+            default: false,
+        }),
+        kill: Flags.boolean({
+            char: "k",
+            description: "Kill ngrok agent entirely",
+            default: false,
+        }),
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TunnelStop);
+        this.parsedFlags = flags;
+        const ngrok = createNgrokManager();
+        const resources = createResourceManager();
+        // Kill ngrok agent entirely
+        if (flags.kill) {
+            killNgrok();
+            if (flags.json || flags.format === "json") {
+                return { success: true, action: "killed" };
+            }
+            this.logInfo("Killed ngrok agent");
+            return { success: true };
+        }
+        // Stop all tunnels
+        if (flags.all) {
+            const tunnels = await listTunnels();
+            let stopped = 0;
+            for (const tunnel of tunnels) {
+                if (await stopTunnel(tunnel.name)) {
+                    stopped++;
+                }
+            }
+            if (flags.json || flags.format === "json") {
+                return { success: true, stopped };
+            }
+            this.logInfo(`Stopped ${stopped} tunnel(s)`);
+            return { success: true, stopped };
+        }
+        // Stop tunnels for a session
+        if (flags.session) {
+            const stopped = await ngrok.stopSession(flags.session);
+            resources.release("ngrok_tunnel", flags.session);
+            if (flags.json || flags.format === "json") {
+                return { success: true, stopped };
+            }
+            this.logInfo(`Stopped ${stopped} tunnel(s) for session ${flags.session}`);
+            return { success: true, stopped };
+        }
+        // Stop specific tunnel by name
+        if (!args.name) {
+            this.error("Provide tunnel name, --session, --all, or --kill");
+        }
+        const stopped = await ngrok.stop(args.name);
+        if (flags.json || flags.format === "json") {
+            return { success: stopped };
+        }
+        if (stopped) {
+            this.logInfo(`Stopped tunnel: ${args.name}`);
+        }
+        else {
+            this.error(`Tunnel not found: ${args.name}`);
+        }
+        return { success: stopped };
+    }
+}

package/dist/cli/commands/tunnel/url.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from "../../base-command.js";
+export default class TunnelUrl extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static examples: string[];
+    static args: {
+        port: import("@oclif/core/interfaces").Arg<number | undefined, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    static flags: {
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected execute(): Promise<unknown>;
+    private tryReadStdin;
+}
+//# sourceMappingURL=url.d.ts.map

package/dist/cli/commands/tunnel/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/tunnel/url.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD,MAAM,CAAC,OAAO,OAAO,SAAU,SAAQ,WAAW;IAChD,OAAgB,WAAW,SAA0D;IACrF,OAAgB,MAAM,UAAS;IAE/B,OAAgB,QAAQ,WAKtB;IAEF,OAAgB,IAAI;;;;;MAIlB;IAEF,OAAgB,KAAK;;;;;MAEnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;YAyC7B,YAAY;CAe3B"}

package/dist/cli/commands/tunnel/url.js

@@ -0,0 +1,70 @@
+import { Args } from "@oclif/core";
+import { findTunnelByPort, getPublicUrl } from "../../../lib/ngrok.js";
+import { BaseCommand } from "../../base-command.js";
+export default class TunnelUrl extends BaseCommand {
+    static description = "Get public URL for a port (creates tunnel if needed)";
+    static hidden = false;
+    static examples = [
+        "<%= config.bin %> tunnel url 3000",
+        "<%= config.bin %> tunnel url 3000 | xargs open",
+        "<%= config.bin %> tunnel url 3000 | pbcopy",
+        "echo 8080 | <%= config.bin %> tunnel url",
+    ];
+    static args = {
+        port: Args.integer({
+            description: "Local port",
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    async execute() {
+        const { args, flags } = await this.parse(TunnelUrl);
+        this.parsedFlags = flags;
+        // Support stdin for port
+        let port = args.port;
+        if (!port) {
+            const stdin = await this.tryReadStdin();
+            if (stdin) {
+                port = parseInt(stdin.trim(), 10);
+            }
+        }
+        if (!port || Number.isNaN(port)) {
+            this.error("Port is required");
+        }
+        const url = await getPublicUrl(port);
+        if (!url) {
+            if (flags.json || flags.format === "json") {
+                return { success: false, port };
+            }
+            process.exit(1);
+        }
+        if (flags.json || flags.format === "json") {
+            const tunnel = await findTunnelByPort(port);
+            return {
+                success: true,
+                port,
+                public_url: url,
+                name: tunnel?.name,
+            };
+        }
+        // Unix pipe output: just the URL
+        this.log(url);
+        return { success: true, url };
+    }
+    async tryReadStdin() {
+        if (process.stdin.isTTY)
+            return undefined;
+        return new Promise((resolve) => {
+            let data = "";
+            process.stdin.setEncoding("utf8");
+            process.stdin.on("data", (chunk) => {
+                data += chunk;
+            });
+            process.stdin.on("end", () => {
+                resolve(data || undefined);
+            });
+            setTimeout(() => resolve(data || undefined), 100);
+        });
+    }
+}

package/dist/cli/commands/web/start.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from "../../base-command.js";
+export default class WebStartCommand extends BaseCommand {
+    static description: string;
+    static hidden: boolean;
+    static aliases: string[];
+    static examples: string[];
+    static flags: {
+        port: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        host: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        tunnel: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        open: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        dev: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected execute(): Promise<unknown>;
+}
+//# sourceMappingURL=start.d.ts.map

package/dist/cli/commands/web/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/web/start.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAIpD,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,WAAW;IACtD,OAAgB,WAAW,SAAmD;IAC9E,OAAgB,MAAM,UAAS;IAC/B,OAAgB,OAAO,WAAW;IAElC,OAAgB,QAAQ,WAKtB;IAEF,OAAgB,KAAK;;;;;;;;;;MAyBnB;cAEc,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CA8E5C"}

package/dist/cli/commands/web/start.js

@@ -0,0 +1,110 @@
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../base-command.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export default class WebStartCommand extends BaseCommand {
+    static description = "Start web UI for agent monitoring and control";
+    static hidden = false;
+    static aliases = ["web"];
+    static examples = [
+        "<%= config.bin %> web start",
+        "<%= config.bin %> web start --port 5173",
+        "<%= config.bin %> web start --host 0.0.0.0",
+        "<%= config.bin %> web start --tunnel",
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        port: Flags.integer({
+            char: "p",
+            description: "Port to listen on",
+            default: 5173,
+        }),
+        host: Flags.string({
+            char: "H",
+            description: "Host to bind to",
+            default: "localhost",
+        }),
+        tunnel: Flags.boolean({
+            description: "Enable Tailscale tunnel for remote access (not yet implemented)",
+            default: false,
+        }),
+        open: Flags.boolean({
+            char: "o",
+            description: "Open browser after starting",
+            default: false,
+        }),
+        dev: Flags.boolean({
+            description: "Development mode (expect Next.js dev server on port 5173)",
+            default: false,
+        }),
+    };
+    async execute() {
+        const { flags } = await this.parse(WebStartCommand);
+        this.parsedFlags = flags;
+        const url = `http://${flags.host}:${flags.port}`;
+        if (flags.json || flags.format === "json") {
+            const packageRoot = join(__dirname, "..", "..", "..", "..");
+            const repoRoot = join(packageRoot, "..", "..");
+            const appDir = join(repoRoot, "apps", "app");
+            return {
+                url,
+                port: flags.port,
+                host: flags.host,
+                dev: flags.dev,
+                appDir,
+            };
+        }
+        this.log(`
+╭─────────────────────────────────────────────╮
+│                                             │
+│   abbie web                                │
+│                                             │
+│   Local:   ${url.padEnd(28)}│
+│                                             │
+${flags.dev ? "│   Mode:    Development (Next.js dev)       │\n" : ""}│   Press Ctrl+C to stop                     │
+│                                             │
+╰─────────────────────────────────────────────╯
+`);
+        if (flags.open) {
+            const openUrl = url;
+            // Open browser (macOS)
+            const { spawn } = await import("node:child_process");
+            spawn("open", [openUrl], { stdio: "ignore", detached: true }).unref();
+        }
+        if (flags.tunnel) {
+            this.logWarn("Tailscale tunnel not yet implemented");
+        }
+        // Start the canonical Next.js app (apps/app)
+        const packageRoot = join(__dirname, "..", "..", "..", "..");
+        const repoRoot = join(packageRoot, "..", "..");
+        const appDir = join(repoRoot, "apps", "app");
+        const { spawn } = await import("node:child_process");
+        const cmd = "pnpm";
+        const baseArgs = ["-C", appDir, "exec", "next"];
+        const nextArgs = flags.dev
+            ? ["dev", "-p", String(flags.port), "-H", flags.host]
+            : ["start", "-p", String(flags.port), "-H", flags.host];
+        const headerSizeFlag = "--max-http-header-size=131072";
+        const existingNodeOptions = process.env.NODE_OPTIONS ?? "";
+        const nextNodeOptions = existingNodeOptions.includes(headerSizeFlag)
+            ? existingNodeOptions
+            : `${existingNodeOptions} ${headerSizeFlag}`.trim();
+        const child = spawn(cmd, [...baseArgs, ...nextArgs], {
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                NODE_OPTIONS: nextNodeOptions,
+            },
+        });
+        await new Promise((resolve, reject) => {
+            child.on("exit", (code) => {
+                if (code === 0)
+                    resolve();
+                reject(new Error(`Next.js exited with code ${code ?? "unknown"}`));
+            });
+            child.on("error", reject);
+        });
+        return;
+    }
+}

package/dist/cli/commands/windows/context.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from "../../base-command.js";
+export default class WindowsContextCommand extends BaseCommand {
+    static summary: string;
+    static hidden: boolean;
+    static examples: string[];
+    static flags: {
+        focus: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "with-buffers": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "max-bytes": import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        redact: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        format: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "json-errors": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    execute(): Promise<unknown>;
+}
+//# sourceMappingURL=context.d.ts.map

package/dist/cli/commands/windows/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/windows/context.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AA+PpD,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,WAAW;IAC5D,OAAgB,OAAO,SAAuD;IAC9E,MAAM,CAAC,MAAM,UAAS;IAEtB,OAAgB,QAAQ,WAOtB;IAEF,OAAgB,KAAK;;;;;;;;;MAoBnB;IAEI,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;CA+IlC"}