@sandblocks/sdk 0.1.0

package/dist/providers/remote.js

@@ -0,0 +1,341 @@
+// src/providers/remote.ts
+import { randomUUID } from "node:crypto";
+import { mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// src/process.ts
+import { spawn } from "node:child_process";
+async function executeProcess(command, options = {}) {
+  if (!command.length || command.some((part) => !part || part.includes("\x00"))) {
+    throw new Error("command must contain safe non-empty arguments");
+  }
+  const startedAt = new Date().toISOString();
+  const [executable, ...args] = command;
+  if (!executable)
+    throw new Error("command executable is required");
+  const child = spawn(executable, args, {
+    cwd: options.cwd ?? options.hostCwd,
+    env: options.env ? { ...process.env, ...options.env } : process.env,
+    stdio: [options.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"]
+  });
+  if (options.stdin !== undefined)
+    child.stdin?.end(options.stdin);
+  let timedOut = false;
+  let stdout = "";
+  let stderr = "";
+  let callbackQueue = Promise.resolve();
+  child.stdout?.on("data", (chunk) => {
+    const text = chunk.toString();
+    stdout = `${stdout}${text}`.slice(-4 * 1024 * 1024);
+    callbackQueue = callbackQueue.then(() => options.onStdout?.(text)).then(() => {
+      return;
+    });
+  });
+  child.stderr?.on("data", (chunk) => {
+    const text = chunk.toString();
+    stderr = `${stderr}${text}`.slice(-4 * 1024 * 1024);
+    callbackQueue = callbackQueue.then(() => options.onStderr?.(text)).then(() => {
+      return;
+    });
+  });
+  const stop = () => child.kill("SIGTERM");
+  options.signal?.addEventListener("abort", stop, { once: true });
+  const timer = options.timeoutMs ? setTimeout(() => {
+    timedOut = true;
+    child.kill("SIGKILL");
+  }, options.timeoutMs) : undefined;
+  try {
+    const exitCode = await new Promise((resolve, reject) => {
+      child.once("error", reject);
+      child.once("close", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
+    });
+    await callbackQueue;
+    if (options.signal?.aborted)
+      throw options.signal.reason ?? new Error("operation aborted");
+    return {
+      exitCode: timedOut ? 124 : exitCode,
+      stdout,
+      stderr,
+      timedOut,
+      startedAt,
+      finishedAt: new Date().toISOString()
+    };
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    options.signal?.removeEventListener("abort", stop);
+  }
+}
+function expandHome(path) {
+  if (path === "~")
+    return process.env.HOME ?? path;
+  if (path.startsWith("~/"))
+    return `${process.env.HOME ?? "~"}/${path.slice(2)}`;
+  return path;
+}
+
+// src/providers/remote.ts
+class RemoteSandblocksProvider {
+  options;
+  kind = "remote";
+  capabilities = {
+    bindMounts: false,
+    isolatedFilesystem: true,
+    persistent: true,
+    networks: true,
+    devices: false,
+    snapshots: false,
+    reconnect: true,
+    remote: true
+  };
+  baseUrl;
+  fetchImpl;
+  constructor(options) {
+    this.options = options;
+    if (!options.apiKey)
+      throw new Error("remote provider API key is required");
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  async create(input) {
+    if (!/^[a-f0-9-]{36}$/.test(input.id))
+      throw new Error("remote sandbox id must be a UUID");
+    if (input.mounts?.length || input.devices?.length || input.groups?.length) {
+      throw new Error("remote provider accepts policy-controlled resources, not host mounts, groups, or devices");
+    }
+    if (Object.keys(input.env ?? {}).length) {
+      throw new Error("remote provider environment must use Sandblocks managed deployment secrets");
+    }
+    const workspaceId = `${input.id.slice(0, 8)}-sdk`;
+    await this.request(`/v1/projects/${encodeURIComponent(this.options.projectId)}/sandboxes`, {
+      method: "POST",
+      body: JSON.stringify({
+        id: input.id,
+        goal: input.metadata?.goal ?? "SDK sandbox",
+        status: "active",
+        previewUrls: [],
+        repositories: [input.metadata?.repository ?? "sdk"],
+        executor: "sandblocks"
+      })
+    });
+    const bundle = await sourceBundle(input.cwd);
+    const response = await this.fetchImpl(`${this.baseUrl}/v1/projects/${encodeURIComponent(this.options.projectId)}/workspaces/import`, {
+      method: "POST",
+      headers: {
+        "x-sandblocks-api-key": this.options.apiKey,
+        "content-type": "application/x-tar",
+        "content-length": String(bundle.byteLength),
+        "x-sandblocks-workspace-id": workspaceId,
+        "x-sandblocks-sandbox-id": input.id,
+        "x-sandblocks-worker-pool": this.options.pool ?? "sandbox-development",
+        ...this.options.workspaceImage ? { "x-sandblocks-workspace-image": this.options.workspaceImage } : {},
+        "idempotency-key": input.idempotencyKey ?? `sdk:${input.id}:import`
+      },
+      body: new Blob([bundle.slice().buffer]),
+      signal: input.signal
+    });
+    const body = await response.json();
+    if (!response.ok || !body.operation)
+      throw new Error(body.error ?? "remote workspace import failed");
+    await this.wait(body.operation.id, input.signal);
+    return this.runtime(input.id, workspaceId, input.cwd);
+  }
+  async reconnect(input) {
+    const workspaceId = `${input.id.slice(0, 8)}-sdk`;
+    await this.request(`/v1/projects/${encodeURIComponent(this.options.projectId)}/sandboxes/${input.id}`);
+    return this.runtime(input.id, workspaceId, input.cwd ?? process.cwd());
+  }
+  runtime(sandboxId, workspaceId, cwd) {
+    const runtime = {
+      id: sandboxId,
+      provider: this.kind,
+      cwd,
+      exec: async (command, options = {}) => {
+        const id = randomUUID();
+        const submitted = await this.request(`/v1/projects/${encodeURIComponent(this.options.projectId)}/operations`, {
+          method: "POST",
+          headers: { "idempotency-key": `sdk:${sandboxId}:exec:${id}` },
+          body: JSON.stringify({
+            kind: "workspace.step.run",
+            stack: this.options.stack ?? "sdk",
+            environmentId: this.options.environmentId,
+            payload: {
+              workspaceId,
+              sandboxId,
+              runtimeType: "sdk",
+              steps: [
+                {
+                  id: `sdk-${id.slice(0, 8)}`,
+                  command,
+                  workingDirectory: options.cwd ?? ".",
+                  timeoutSeconds: Math.ceil((options.timeoutMs ?? 900000) / 1000),
+                  required: true
+                }
+              ],
+              placement: this.options.hostId ? { hostId: this.options.hostId } : { pool: this.options.pool ?? "sandbox-development" }
+            },
+            maxAttempts: 1
+          }),
+          signal: options.signal
+        });
+        return this.waitExec(submitted.operation.id, options);
+      },
+      stop: async () => {
+        await this.request(`/v1/projects/${encodeURIComponent(this.options.projectId)}/sandboxes/${sandboxId}/operations/cancel`, { method: "POST" });
+      },
+      destroy: async () => {
+        const destroyed = await this.request(`/v1/projects/${encodeURIComponent(this.options.projectId)}/workspaces/${workspaceId}`, {
+          method: "DELETE",
+          headers: { "idempotency-key": `sdk:${sandboxId}:destroy` }
+        }).catch(() => ({}));
+        if (destroyed.operation?.id)
+          await this.wait(destroyed.operation.id).catch(() => {
+            return;
+          });
+        await this.request(`/v1/projects/${encodeURIComponent(this.options.projectId)}/sandboxes`, {
+          method: "POST",
+          body: JSON.stringify({
+            id: sandboxId,
+            goal: "SDK sandbox",
+            status: "destroyed",
+            previewUrls: [],
+            repositories: [],
+            executor: "sandblocks"
+          })
+        }).catch(() => {
+          return;
+        });
+      }
+    };
+    runtime.syncToHost = async () => {
+      const commits = await runtime.exec([
+        "git",
+        "format-patch",
+        "--binary",
+        "--stdout",
+        "refs/sandblocks/base..HEAD"
+      ]);
+      if (commits.exitCode !== 0)
+        throw new Error(commits.stderr || "remote commit export failed");
+      if (commits.stdout.trim()) {
+        const applied = await executeProcess(["git", "-C", cwd, "am"], { stdin: commits.stdout });
+        if (applied.exitCode !== 0) {
+          await executeProcess(["git", "-C", cwd, "am", "--abort"]);
+          throw new Error(applied.stderr || "remote commits could not be applied to the host worktree");
+        }
+      }
+      const changes = await runtime.exec(["git", "diff", "--binary", "HEAD"]);
+      if (changes.exitCode !== 0)
+        throw new Error(changes.stderr || "remote change export failed");
+      if (changes.stdout.trim()) {
+        const applied = await executeProcess(["git", "-C", cwd, "apply"], { stdin: changes.stdout });
+        if (applied.exitCode !== 0)
+          throw new Error(applied.stderr || "remote changes could not be applied");
+      }
+    };
+    return runtime;
+  }
+  async waitExec(operationId, options) {
+    let sequence = 0;
+    let stdout = "";
+    let stderr = "";
+    const startedAt = new Date().toISOString();
+    while (true) {
+      if (options.signal?.aborted) {
+        await this.request(`/v1/operations/${operationId}/cancel`, { method: "POST" }).catch(() => {
+          return;
+        });
+        throw options.signal.reason ?? new Error("operation aborted");
+      }
+      const events = await this.request(`/v1/operations/${operationId}/events?after=${sequence}`);
+      for (const event of events.events) {
+        sequence = Math.max(sequence, event.sequence);
+        if (event.kind !== "operation.log")
+          continue;
+        const message = String(event.payload.message ?? "");
+        if (event.payload.stream === "stderr") {
+          stderr += message;
+          await options.onStderr?.(message);
+        } else {
+          stdout += message;
+          await options.onStdout?.(message);
+        }
+      }
+      const { operation } = await this.request(`/v1/operations/${operationId}`);
+      if (operation.state === "succeeded")
+        return {
+          exitCode: 0,
+          stdout,
+          stderr,
+          timedOut: false,
+          startedAt,
+          finishedAt: new Date().toISOString()
+        };
+      if (operation.state === "failed" || operation.state === "cancelled")
+        return {
+          exitCode: 1,
+          stdout,
+          stderr: stderr || operation.failureReason || operation.state,
+          timedOut: false,
+          startedAt,
+          finishedAt: new Date().toISOString()
+        };
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+  }
+  async wait(operationId, signal) {
+    const result = await this.waitExec(operationId, { signal });
+    if (result.exitCode !== 0)
+      throw new Error(result.stderr || "remote operation failed");
+  }
+  async request(path, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("x-sandblocks-api-key", this.options.apiKey);
+    if (init.body)
+      headers.set("content-type", "application/json");
+    const response = await this.fetchImpl(`${this.baseUrl}${path}`, { ...init, headers });
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok)
+      throw new Error(body.error ?? `Sandblocks request failed (${response.status})`);
+    return body;
+  }
+}
+function remoteSandblocks(options) {
+  return new RemoteSandblocksProvider(options);
+}
+async function sourceBundle(cwd) {
+  const temporary = await mkdtemp(join(tmpdir(), "sandblocks-sdk-source-"));
+  const file = join(temporary, "source.tar");
+  const list = join(temporary, "files.list");
+  try {
+    const listed = await executeProcess([
+      "git",
+      "-C",
+      cwd,
+      "ls-files",
+      "--cached",
+      "--others",
+      "--exclude-standard",
+      "-z"
+    ]);
+    if (listed.exitCode !== 0)
+      throw new Error("remote source directory must be a Git worktree");
+    const files = listed.stdout.split("\x00").filter((path) => path && path !== ".sandblocks" && !path.startsWith(".sandblocks/") && path !== ".git");
+    if (!files.length || files.length > 50000)
+      throw new Error("remote source bundle file count is invalid");
+    await writeFile(list, `${files.join("\x00")}\x00`);
+    const result = await executeProcess(["tar", "-C", cwd, "--null", "-T", list, "-cf", file]);
+    if (result.exitCode !== 0)
+      throw new Error(`source archive failed: ${result.stderr}`);
+    if ((await stat(file)).size > 512 * 1024 * 1024)
+      throw new Error("remote source bundle exceeds 512 MiB");
+    return new Uint8Array(await readFile(file));
+  } finally {
+    await rm(temporary, { recursive: true, force: true });
+  }
+}
+export {
+  remoteSandblocks,
+  RemoteSandblocksProvider
+};

package/dist/providers/unsafe-host.js

@@ -0,0 +1,126 @@
+// src/providers/unsafe-host.ts
+import { cp, realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+
+// src/process.ts
+import { spawn } from "node:child_process";
+async function executeProcess(command, options = {}) {
+  if (!command.length || command.some((part) => !part || part.includes("\x00"))) {
+    throw new Error("command must contain safe non-empty arguments");
+  }
+  const startedAt = new Date().toISOString();
+  const [executable, ...args] = command;
+  if (!executable)
+    throw new Error("command executable is required");
+  const child = spawn(executable, args, {
+    cwd: options.cwd ?? options.hostCwd,
+    env: options.env ? { ...process.env, ...options.env } : process.env,
+    stdio: [options.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"]
+  });
+  if (options.stdin !== undefined)
+    child.stdin?.end(options.stdin);
+  let timedOut = false;
+  let stdout = "";
+  let stderr = "";
+  let callbackQueue = Promise.resolve();
+  child.stdout?.on("data", (chunk) => {
+    const text = chunk.toString();
+    stdout = `${stdout}${text}`.slice(-4 * 1024 * 1024);
+    callbackQueue = callbackQueue.then(() => options.onStdout?.(text)).then(() => {
+      return;
+    });
+  });
+  child.stderr?.on("data", (chunk) => {
+    const text = chunk.toString();
+    stderr = `${stderr}${text}`.slice(-4 * 1024 * 1024);
+    callbackQueue = callbackQueue.then(() => options.onStderr?.(text)).then(() => {
+      return;
+    });
+  });
+  const stop = () => child.kill("SIGTERM");
+  options.signal?.addEventListener("abort", stop, { once: true });
+  const timer = options.timeoutMs ? setTimeout(() => {
+    timedOut = true;
+    child.kill("SIGKILL");
+  }, options.timeoutMs) : undefined;
+  try {
+    const exitCode = await new Promise((resolve, reject) => {
+      child.once("error", reject);
+      child.once("close", (code, signal) => resolve(code ?? (signal ? 128 : 1)));
+    });
+    await callbackQueue;
+    if (options.signal?.aborted)
+      throw options.signal.reason ?? new Error("operation aborted");
+    return {
+      exitCode: timedOut ? 124 : exitCode,
+      stdout,
+      stderr,
+      timedOut,
+      startedAt,
+      finishedAt: new Date().toISOString()
+    };
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    options.signal?.removeEventListener("abort", stop);
+  }
+}
+function expandHome(path) {
+  if (path === "~")
+    return process.env.HOME ?? path;
+  if (path.startsWith("~/"))
+    return `${process.env.HOME ?? "~"}/${path.slice(2)}`;
+  return path;
+}
+
+// src/providers/unsafe-host.ts
+class UnsafeHostProvider {
+  options;
+  kind = "unsafe-host";
+  capabilities = {
+    bindMounts: false,
+    isolatedFilesystem: false,
+    persistent: true,
+    networks: false,
+    devices: false,
+    snapshots: false,
+    reconnect: false,
+    remote: false
+  };
+  constructor(options) {
+    this.options = options;
+    if (options.acknowledgeHostExecutionRisk !== true)
+      throw new Error("host execution risk must be acknowledged");
+  }
+  async create(input) {
+    if (input.mounts?.length || input.devices?.length || input.network) {
+      throw new Error("unsafe host provider does not accept sandbox isolation options");
+    }
+    const cwd = await realpath(input.cwd);
+    return {
+      id: input.id,
+      provider: this.kind,
+      cwd,
+      exec: (command, options = {}) => executeProcess(command, {
+        ...options,
+        cwd: options.cwd ? resolve(cwd, options.cwd) : cwd,
+        env: { ...this.options.env, ...input.env, ...options.env }
+      }),
+      upload: async (source, destination) => {
+        await cp(resolve(cwd, source), resolve(cwd, destination), { recursive: true });
+      },
+      download: async (source, destination) => {
+        await cp(resolve(cwd, source), resolve(cwd, destination), { recursive: true });
+      },
+      stop: async () => {},
+      destroy: async () => {}
+    };
+  }
+}
+function unsafeHost(options) {
+  return new UnsafeHostProvider(options);
+}
+export {
+  unsafeHost,
+  UnsafeHostProvider
+};

package/dist/types/agents.d.ts

@@ -0,0 +1,63 @@
+import type { AgentContext, AgentIterationResult, AgentProvider, AgentStreamEvent } from "./types.js";
+export interface CommandAgentOptions {
+    id?: string;
+    command: string[] | ((context: AgentContext) => string[]);
+    env?: Record<string, string>;
+    prompt?: "stdin" | "argument" | "none";
+    parseEvent?: (line: string, context: {
+        iteration: number;
+        timestamp: string;
+    }) => AgentStreamEvent | AgentStreamEvent[] | undefined;
+    sessionId?: (stdout: string, stderr: string) => string | undefined;
+}
+export declare class CommandAgent implements AgentProvider {
+    protected readonly options: CommandAgentOptions;
+    readonly id: string;
+    constructor(options: CommandAgentOptions);
+    run(context: AgentContext): Promise<AgentIterationResult>;
+    private result;
+    private emitLine;
+}
+export interface AgentCredentialReference {
+    /** Environment variable name. Remote providers resolve it from Sandblocks managed secrets. */
+    environment: string;
+    /** Optional variable name exposed to the agent process. */
+    target?: string;
+}
+export interface ClaudeCodeAgentOptions {
+    model: string;
+    credential?: AgentCredentialReference;
+    effort?: "low" | "medium" | "high" | "max";
+    binary?: string;
+    env?: Record<string, string>;
+    extraArgs?: string[];
+}
+export declare class ClaudeCodeAgent extends CommandAgent {
+    constructor(options: ClaudeCodeAgentOptions);
+}
+export interface CodexAgentOptions {
+    model: string;
+    credential?: AgentCredentialReference;
+    reasoningEffort?: "low" | "medium" | "high" | "xhigh";
+    binary?: string;
+    env?: Record<string, string>;
+    extraArgs?: string[];
+}
+export declare class CodexAgent extends CommandAgent {
+    constructor(options: CodexAgentOptions);
+}
+export interface PiAgentOptions {
+    model: string;
+    credential?: AgentCredentialReference;
+    binary?: string;
+    env?: Record<string, string>;
+    skills?: string[];
+    extraArgs?: string[];
+}
+export declare class PiAgent extends CommandAgent {
+    constructor(options: PiAgentOptions);
+}
+export declare const claudeCode: (model: string, options?: Omit<ClaudeCodeAgentOptions, "model">) => ClaudeCodeAgent;
+export declare const codex: (model: string, options?: Omit<CodexAgentOptions, "model">) => CodexAgent;
+export declare const pi: (model: string, options?: Omit<PiAgentOptions, "model">) => PiAgent;
+//# sourceMappingURL=agents.d.ts.map

package/dist/types/agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/agents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEtG,MAAM,WAAW,mBAAmB;IAClC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE,YAAY,KAAK,MAAM,EAAE,CAAC,CAAC;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,OAAO,GAAG,UAAU,GAAG,MAAM,CAAC;IACvC,UAAU,CAAC,EAAE,CACX,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,KAC9C,gBAAgB,GAAG,gBAAgB,EAAE,GAAG,SAAS,CAAC;IACvD,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACpE;AAED,qBAAa,YAAa,YAAW,aAAa;IAEpC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,mBAAmB;IAD3D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;gBACW,OAAO,EAAE,mBAAmB;IAIrD,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAgE/D,OAAO,CAAC,MAAM;YAqBA,QAAQ;CAiBvB;AAED,MAAM,WAAW,wBAAwB;IACvC,8FAA8F;IAC9F,WAAW,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,wBAAwB,CAAC;IACtC,MAAM,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AACD,qBAAa,eAAgB,SAAQ,YAAY;gBACnC,OAAO,EAAE,sBAAsB;CAiB5C;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,wBAAwB,CAAC;IACtC,eAAe,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;IACtD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AACD,qBAAa,UAAW,SAAQ,YAAY;gBAC9B,OAAO,EAAE,iBAAiB;CAiBvC;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,wBAAwB,CAAC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AACD,qBAAa,OAAQ,SAAQ,YAAY;gBAC3B,OAAO,EAAE,cAAc;CAiBpC;AAED,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,EAAE,UAAS,IAAI,CAAC,sBAAsB,EAAE,OAAO,CAAM,oBACjD,CAAC;AAC7C,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,EAAE,UAAS,IAAI,CAAC,iBAAiB,EAAE,OAAO,CAAM,eAC5C,CAAC;AACxC,eAAO,MAAM,EAAE,GAAI,OAAO,MAAM,EAAE,UAAS,IAAI,CAAC,cAAc,EAAE,OAAO,CAAM,YACzC,CAAC"}

package/dist/types/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/types/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../src/bin.ts"],"names":[],"mappings":""}