@getollie/cli 0.0.5 → 0.2.1

package/dist/cli.js

@@ -0,0 +1,2598 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { CommanderError } from "commander";
+
+// src/cli-program.ts
+import { Command } from "commander";
+
+// src/config.ts
+import { access, stat } from "fs/promises";
+import { resolve as resolve2 } from "path";
+
+// src/sandbox/mounts.ts
+import { realpathSync, statSync } from "fs";
+import { posix, resolve } from "path";
+
+// src/utils/errors.ts
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+  exitCode;
+};
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/sandbox/mounts.ts
+var SANDBOX_WORKSPACE_PATH = "/workspace";
+function pathsOverlap(left, right) {
+  return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+function validateMountPoint(mountPoint) {
+  if (!posix.isAbsolute(mountPoint) || mountPoint === "/" || mountPoint.includes("\\") || mountPoint.includes("\0") || posix.normalize(mountPoint) !== mountPoint) {
+    throw new CliError(
+      `Mount point must be a normalized absolute sandbox path other than /: ${mountPoint}`
+    );
+  }
+  if (pathsOverlap(mountPoint, SANDBOX_WORKSPACE_PATH)) {
+    throw new CliError(`Mount point must be outside ${SANDBOX_WORKSPACE_PATH}: ${mountPoint}`);
+  }
+}
+function validateSandboxMounts(mounts) {
+  const validated = [];
+  for (const mount of mounts) {
+    validateMountPoint(mount.mountPoint);
+    let hostPath;
+    try {
+      hostPath = realpathSync(resolve(mount.hostPath));
+      if (!statSync(hostPath).isDirectory()) {
+        throw new Error("not a directory");
+      }
+    } catch {
+      throw new CliError(
+        `Mount source does not exist or is not a directory: ${resolve(mount.hostPath)}`
+      );
+    }
+    const conflict = validated.find(
+      (candidate) => pathsOverlap(candidate.mountPoint, mount.mountPoint)
+    );
+    if (conflict) {
+      throw new CliError(
+        `Mount points must not overlap: ${conflict.mountPoint} and ${mount.mountPoint}`
+      );
+    }
+    validated.push({ hostPath, mountPoint: mount.mountPoint });
+  }
+  return validated;
+}
+function parseSandboxMounts(specs = []) {
+  const mounts = specs.map((spec) => {
+    const separator = spec.lastIndexOf(":");
+    if (separator <= 0 || separator === spec.length - 1) {
+      throw new CliError(
+        `Invalid mount ${JSON.stringify(spec)}. Expected <host-path>:<sandbox-path>`
+      );
+    }
+    return {
+      hostPath: spec.slice(0, separator),
+      mountPoint: spec.slice(separator + 1)
+    };
+  });
+  return validateSandboxMounts(mounts);
+}
+
+// src/config.ts
+var DEFAULT_PROVIDER = "openai";
+var DEFAULT_MODEL = "gpt-5.6";
+var DEFAULT_MAX_STEPS = 20;
+var DEFAULT_COMMAND_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_OUTPUT_BYTES = 65536;
+var DEFAULT_EXECUTOR = "none";
+function parseNumber(name, value, fallback) {
+  if (value === void 0 || value === "") {
+    return fallback;
+  }
+  const parsed = typeof value === "number" ? value : Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new CliError(`${name} must be a non-negative integer`);
+  }
+  return Math.floor(parsed);
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function parseExecutor(value) {
+  const executor = value ?? DEFAULT_EXECUTOR;
+  if (executor !== "none" && executor !== "local" && executor !== "daytona") {
+    throw new CliError(`Unsupported executor: ${executor}. Expected one of: none, local, daytona`);
+  }
+  return executor;
+}
+async function resolveRunConfig(input = {}, env = process.env) {
+  const cwd = resolve2(input.cwd ?? env.OLLIE_CWD ?? process.cwd());
+  const stats = await stat(cwd).catch(() => null);
+  if (!stats?.isDirectory()) {
+    throw new CliError(`Working directory does not exist or is not a directory: ${cwd}`);
+  }
+  await access(cwd);
+  const executor = parseExecutor(input.executor ?? env.OLLIE_EXECUTOR);
+  return {
+    cwd,
+    mounts: parseSandboxMounts(input.mount),
+    provider: input.provider ?? env.OLLIE_PROVIDER ?? DEFAULT_PROVIDER,
+    model: input.model ?? env.OLLIE_MODEL ?? DEFAULT_MODEL,
+    executor,
+    maxSteps: clamp(
+      parseNumber("max steps", input.maxSteps ?? env.OLLIE_MAX_STEPS, DEFAULT_MAX_STEPS),
+      1,
+      100
+    ),
+    commandTimeoutMs: clamp(
+      parseNumber(
+        "command timeout",
+        input.timeout ?? env.OLLIE_COMMAND_TIMEOUT_MS,
+        DEFAULT_COMMAND_TIMEOUT_MS
+      ),
+      1,
+      3e5
+    ),
+    maxOutputBytes: clamp(
+      parseNumber(
+        "max output",
+        input.maxOutput ?? env.OLLIE_MAX_OUTPUT_BYTES,
+        DEFAULT_MAX_OUTPUT_BYTES
+      ),
+      1,
+      2e6
+    ),
+    ndjson: input.ndjson ?? false,
+    json: input.json ?? false,
+    color: input.color ?? !env.NO_COLOR
+  };
+}
+
+// src/doctor.ts
+import { access as access2, stat as stat2 } from "fs/promises";
+
+// src/sandbox/just-bash.ts
+import { realpathSync as realpathSync2, statSync as statSync2 } from "fs";
+import { Bash, InMemoryFs, MountableFs, ReadWriteFs } from "just-bash";
+
+// src/sandbox/git/index.ts
+import { posix as posix3 } from "path";
+import { createTwoFilesPatch } from "diff";
+import * as git from "isomorphic-git";
+import { defineCommand } from "just-bash";
+
+// src/sandbox/git/fs-adapter.ts
+import { posix as posix2 } from "path";
+var ROOT = "/workspace";
+function safePath(path) {
+  if (path.includes("\0") || path.includes("\\")) {
+    throw Object.assign(new Error("Invalid virtual Git path"), { code: "EINVAL" });
+  }
+  const normalized = posix2.resolve(path);
+  if (normalized !== ROOT && !normalized.startsWith(`${ROOT}/`)) {
+    throw Object.assign(new Error("Git path is outside /workspace"), { code: "EACCES" });
+  }
+  return normalized;
+}
+function normalizeError(error) {
+  if (error instanceof Error) {
+    const coded = error;
+    if (!coded.code) {
+      if (/not found|does not exist|enoent/i.test(error.message)) coded.code = "ENOENT";
+      else if (/exist/i.test(error.message)) coded.code = "EEXIST";
+      else if (/directory/i.test(error.message)) coded.code = "ENOTDIR";
+      else coded.code = "EIO";
+    }
+    throw coded;
+  }
+  throw Object.assign(new Error("Virtual filesystem operation failed"), { code: "EIO" });
+}
+async function ensureParent(fs, path) {
+  const parent = posix2.dirname(path);
+  if (!await fs.exists(parent)) await fs.mkdir(parent, { recursive: true });
+}
+function statShape(stat4) {
+  const typeMode = stat4.isDirectory ? 16384 : stat4.isSymbolicLink ? 40960 : 32768;
+  const mode = typeMode | stat4.mode & 4095;
+  return {
+    isFile: () => stat4.isFile,
+    isDirectory: () => stat4.isDirectory,
+    isSymbolicLink: () => stat4.isSymbolicLink,
+    mode,
+    size: stat4.size,
+    mtime: stat4.mtime,
+    mtimeMs: stat4.mtime.getTime(),
+    ctimeMs: stat4.mtime.getTime(),
+    ino: 0,
+    uid: 0,
+    gid: 0,
+    dev: 0
+  };
+}
+function createGitFs(fs) {
+  const promises = {
+    async readFile(path, options) {
+      try {
+        const virtualPath2 = safePath(path);
+        const encoding = typeof options === "string" ? options : options?.encoding;
+        return encoding ? fs.readFile(virtualPath2, "utf8") : fs.readFileBuffer(virtualPath2);
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async writeFile(path, data) {
+      try {
+        const virtualPath2 = safePath(path);
+        await ensureParent(fs, virtualPath2);
+        await fs.writeFile(virtualPath2, data);
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async unlink(path) {
+      try {
+        await fs.rm(safePath(path));
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async readdir(path) {
+      try {
+        return await fs.readdir(safePath(path));
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async mkdir(path) {
+      try {
+        await fs.mkdir(safePath(path), { recursive: true });
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async rmdir(path) {
+      try {
+        await fs.rm(safePath(path));
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async rename(from, to) {
+      try {
+        await ensureParent(fs, safePath(to));
+        await fs.mv(safePath(from), safePath(to));
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async stat(path) {
+      try {
+        return statShape(await fs.stat(safePath(path)));
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async lstat(path) {
+      try {
+        return statShape(await fs.lstat(safePath(path)));
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async readlink(path) {
+      try {
+        return await fs.readlink(safePath(path));
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async symlink(target, path) {
+      try {
+        await fs.symlink(target, safePath(path));
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async chmod(path, mode) {
+      try {
+        await fs.chmod(safePath(path), mode);
+      } catch (error) {
+        normalizeError(error);
+      }
+    },
+    async utimes(path, atime, mtime) {
+      try {
+        await fs.utimes(safePath(path), atime, mtime);
+      } catch (error) {
+        normalizeError(error);
+      }
+    }
+  };
+  return { promises };
+}
+
+// src/sandbox/git/http-adapter.ts
+function isPrivateLiteralHost(hostname) {
+  const host = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (host === "localhost" || host.endsWith(".localhost") || host === "::1") return true;
+  const octets = host.split(".").map(Number);
+  if (octets.length !== 4 || octets.some((octet) => !Number.isInteger(octet))) return false;
+  return octets[0] === 10 || octets[0] === 127 || octets[0] === 169 && octets[1] === 254 || octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31 || octets[0] === 192 && octets[1] === 168;
+}
+function validateRemoteUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Only absolute HTTPS remote URLs are supported");
+  }
+  if (url.protocol !== "https:") throw new Error("Only HTTPS remote URLs are supported");
+  if (url.username || url.password) throw new Error("Remote URLs must not contain credentials");
+  if (url.hash) throw new Error("Remote URLs must not contain fragments");
+  if (isPrivateLiteralHost(url.hostname)) {
+    throw new Error("Remote URLs must not target local or private hosts");
+  }
+  return url.toString();
+}
+async function collectBody(body, signal) {
+  if (!body) return new Uint8Array();
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of body) {
+    if (signal?.aborted) throw new Error("Git operation was aborted");
+    chunks.push(chunk);
+    size += chunk.byteLength;
+  }
+  const result = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
+async function* oneChunk(body) {
+  yield body;
+}
+function createGitHttp(ctx) {
+  return {
+    async request(request) {
+      if (!ctx.fetch) throw new Error("Network access is not configured for this sandbox");
+      if (ctx.signal?.aborted) throw new Error("Git operation was aborted");
+      const url = validateRemoteUrl(request.url);
+      const bytes = await collectBody(request.body, ctx.signal);
+      const response = await ctx.fetch(url, {
+        method: request.method ?? "GET",
+        headers: request.headers,
+        // SecureFetch forwards BodyInit values unchanged, but its public type is narrower.
+        body: bytes.length > 0 ? bytes : void 0,
+        followRedirects: true
+      });
+      if (ctx.signal?.aborted) throw new Error("Git operation was aborted");
+      const finalUrl = validateRemoteUrl(response.url);
+      return {
+        url: finalUrl,
+        method: request.method,
+        headers: response.headers,
+        body: oneChunk(response.body),
+        statusCode: response.status,
+        statusMessage: response.statusText
+      };
+    }
+  };
+}
+
+// src/sandbox/git/index.ts
+var WORKSPACE = "/workspace";
+var VERSION = "ollie-git/0.1 (isomorphic-git)";
+var COMMANDS = [
+  "init",
+  "clone",
+  "status",
+  "add",
+  "commit",
+  "log",
+  "diff",
+  "branch",
+  "checkout",
+  "remote",
+  "config",
+  "fetch",
+  "pull",
+  "push"
+];
+var UsageError = class extends Error {
+};
+function ok(stdout = "") {
+  return { stdout, stderr: "", exitCode: 0 };
+}
+function usage(message) {
+  throw new UsageError(message ?? "unsupported arguments");
+}
+function assertNotAborted(ctx) {
+  if (ctx.signal?.aborted) throw new Error("operation aborted");
+}
+function virtualPath(ctx, input = ".") {
+  if (input.includes("\0") || input.includes("\\")) throw new Error("invalid path");
+  const resolved = ctx.fs.resolvePath(ctx.cwd, input);
+  if (resolved !== WORKSPACE && !resolved.startsWith(`${WORKSPACE}/`)) {
+    throw new Error("path is outside /workspace");
+  }
+  return resolved;
+}
+async function repositoryDir(ctx) {
+  let current = virtualPath(ctx);
+  while (current === WORKSPACE || current.startsWith(`${WORKSPACE}/`)) {
+    if (await ctx.fs.exists(posix3.join(current, ".git"))) return current;
+    if (current === WORKSPACE) break;
+    current = posix3.dirname(current);
+  }
+  throw new Error("not a git repository (or any parent up to /workspace)");
+}
+function optionValue(args, names) {
+  let value;
+  const rest = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg && names.includes(arg)) {
+      const next = args[++index];
+      if (!next) usage(`${arg} requires a value`);
+      value = next;
+    } else if (arg && names.some((name) => arg.startsWith(`${name}=`))) {
+      value = arg.slice(arg.indexOf("=") + 1);
+    } else if (arg) rest.push(arg);
+  }
+  return { value, rest };
+}
+function flag(args, names) {
+  let enabled = false;
+  const rest = args.filter((arg) => {
+    if (names.includes(arg)) {
+      enabled = true;
+      return false;
+    }
+    return true;
+  });
+  return { enabled, rest };
+}
+function rejectOptions(args) {
+  const unknown = args.find((arg) => arg.startsWith("-"));
+  if (unknown) usage(`unsupported option '${unknown}'`);
+}
+function positiveInteger(value, option) {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) usage(`${option} requires a positive integer`);
+  return parsed;
+}
+function authFor(context, url) {
+  if (!url || !context.options.resolveAuth) return void 0;
+  return async () => context.options.resolveAuth?.(url);
+}
+async function remoteUrl(context, dir, remote) {
+  const value = await git.getConfig({ fs: context.fs, dir, path: `remote.${remote}.url` });
+  if (!value) throw new Error(`remote '${remote}' has no URL`);
+  return validateRemoteUrl(value);
+}
+var GLOBAL_CONFIG_PATH = "/home/user/.gitconfig";
+async function readGlobalConfig(ctx) {
+  if (!await ctx.fs.exists(GLOBAL_CONFIG_PATH)) return /* @__PURE__ */ new Map();
+  const values = /* @__PURE__ */ new Map();
+  let section = "";
+  for (const rawLine of (await ctx.fs.readFile(GLOBAL_CONFIG_PATH)).split("\n")) {
+    const line = rawLine.trim();
+    const sectionMatch = /^\[([^\]]+)\]$/.exec(line);
+    if (sectionMatch?.[1]) {
+      section = sectionMatch[1].trim().toLowerCase();
+      continue;
+    }
+    const valueMatch = /^([^=]+)=(.*)$/.exec(line);
+    if (section && valueMatch?.[1] !== void 0 && valueMatch[2] !== void 0) {
+      values.set(`${section}.${valueMatch[1].trim().toLowerCase()}`, valueMatch[2].trim());
+    }
+  }
+  return values;
+}
+async function writeGlobalConfig(ctx, values) {
+  const sections = /* @__PURE__ */ new Map();
+  for (const [path, value] of [...values].sort(([left], [right]) => left.localeCompare(right))) {
+    const separator = path.indexOf(".");
+    if (separator < 1) usage("config key must contain a section");
+    const section = path.slice(0, separator);
+    const name = path.slice(separator + 1);
+    const entries = sections.get(section) ?? [];
+    entries.push([name, value]);
+    sections.set(section, entries);
+  }
+  const content = [...sections].map(
+    ([section, entries]) => `[${section}]
+${entries.map(([key, value]) => `	${key} = ${value}`).join("\n")}`
+  ).join("\n");
+  await ctx.fs.mkdir(posix3.dirname(GLOBAL_CONFIG_PATH), { recursive: true });
+  await ctx.fs.writeFile(GLOBAL_CONFIG_PATH, content ? `${content}
+` : "");
+}
+async function handleInit(context, args) {
+  const branchOpt = optionValue(args, ["-b", "--initial-branch"]);
+  rejectOptions(branchOpt.rest);
+  if (branchOpt.rest.length > 1) usage("git init accepts at most one directory");
+  const dir = virtualPath(context.command, branchOpt.rest[0]);
+  await context.command.fs.mkdir(dir, { recursive: true }).catch(async () => {
+    if (!await context.command.fs.exists(dir))
+      throw new Error("cannot create repository directory");
+  });
+  await git.init({ fs: context.fs, dir, defaultBranch: branchOpt.value ?? "main" });
+  return ok(`Initialized empty Git repository in ${posix3.join(dir, ".git")}/
+`);
+}
+async function handleStatus(context, args) {
+  const shortFlag = flag(args, ["-s", "--short", "--porcelain"]);
+  rejectOptions(shortFlag.rest);
+  if (shortFlag.rest.length) usage();
+  const dir = await repositoryDir(context.command);
+  const matrix = await git.statusMatrix({ fs: context.fs, dir });
+  const lines = matrix.filter(([, head, workdir, stage]) => head !== workdir || workdir !== stage).map(([path, head, workdir, stage]) => {
+    let x = " ";
+    let y = " ";
+    if (head === 0 && stage !== 0) x = "A";
+    else if (head !== stage) x = stage === 0 ? "D" : "M";
+    if (workdir !== stage) y = workdir === 0 ? "D" : "M";
+    if (head === 0 && stage === 0 && workdir !== 0) return `?? ${path}`;
+    return `${x}${y} ${path}`;
+  });
+  if (shortFlag.enabled) return ok(lines.length ? `${lines.join("\n")}
+` : "");
+  const branch2 = await git.currentBranch({ fs: context.fs, dir }) ?? "HEAD detached";
+  return ok(
+    `On branch ${branch2}
+${lines.length ? `${lines.join("\n")}
+` : "nothing to commit, working tree clean\n"}`
+  );
+}
+async function handleAdd(context, args) {
+  const separator = args.indexOf("--");
+  const optionArgs = separator < 0 ? args : args.slice(0, separator);
+  const literalPaths = separator < 0 ? [] : args.slice(separator + 1);
+  const allFlag = flag(optionArgs, ["-A", "--all"]);
+  rejectOptions(allFlag.rest);
+  const paths = [...allFlag.rest, ...literalPaths];
+  if (!allFlag.enabled && paths.length === 0) usage("nothing specified");
+  const dir = await repositoryDir(context.command);
+  const all = allFlag.enabled || paths.includes(".");
+  if (all) {
+    const matrix = await git.statusMatrix({ fs: context.fs, dir });
+    for (const [filepath, , workdir, stage] of matrix) {
+      assertNotAborted(context.command);
+      if (workdir === stage) continue;
+      if (workdir === 0) await git.remove({ fs: context.fs, dir, filepath });
+      else await git.add({ fs: context.fs, dir, filepath });
+    }
+  } else {
+    for (const filepath of paths) {
+      if (filepath.startsWith("/") || filepath.split("/").some((segment) => segment === ".." || segment === ".git"))
+        throw new Error("invalid pathspec");
+      await git.add({ fs: context.fs, dir, filepath });
+    }
+  }
+  return ok();
+}
+function parseAuthor(value) {
+  const match = /^(.*?)\s*<([^<>]+)>$/.exec(value);
+  if (!match?.[1] || !match[2]) usage("--author must be 'Name <email>'");
+  return { name: match[1].trim(), email: match[2] };
+}
+async function handleCommit(context, args) {
+  const messageOpt = optionValue(args, ["-m", "--message"]);
+  const authorOpt = optionValue(messageOpt.rest, ["--author"]);
+  rejectOptions(authorOpt.rest);
+  if (authorOpt.rest.length || !messageOpt.value) usage("git commit requires -m <message>");
+  const dir = await repositoryDir(context.command);
+  const globalConfig = await readGlobalConfig(context.command);
+  const repoName = await git.getConfig({ fs: context.fs, dir, path: "user.name" });
+  const repoEmail = await git.getConfig({ fs: context.fs, dir, path: "user.email" });
+  const configuredAuthor = repoName && repoEmail ? { name: repoName, email: repoEmail } : globalConfig.get("user.name") && globalConfig.get("user.email") ? {
+    name: globalConfig.get("user.name"),
+    email: globalConfig.get("user.email")
+  } : context.options.author;
+  const author = authorOpt.value ? parseAuthor(authorOpt.value) : configuredAuthor;
+  const matrix = await git.statusMatrix({ fs: context.fs, dir });
+  if (!matrix.some(([, headStatus, , stageStatus]) => headStatus !== stageStatus)) {
+    const message = matrix.some(([, , workdirStatus, stageStatus]) => workdirStatus !== stageStatus) ? "no changes added to commit" : "nothing to commit, working tree clean";
+    throw new Error(message);
+  }
+  const oid = await git.commit({ fs: context.fs, dir, message: messageOpt.value, author });
+  const branch2 = await git.currentBranch({ fs: context.fs, dir }) ?? "detached HEAD";
+  return ok(`[${branch2} ${oid.slice(0, 7)}] ${messageOpt.value.split("\n")[0]}
+`);
+}
+async function handleLog(context, args) {
+  const countOpt = optionValue(args, ["-n", "--max-count"]);
+  const onelineFlag = flag(countOpt.rest, ["--oneline"]);
+  rejectOptions(onelineFlag.rest);
+  if (onelineFlag.rest.length > 1) usage();
+  const depth = countOpt.value ? Number.parseInt(countOpt.value, 10) : 20;
+  if (!Number.isFinite(depth) || depth < 1) usage("invalid max count");
+  const dir = await repositoryDir(context.command);
+  const commits = await git.log({ fs: context.fs, dir, ref: onelineFlag.rest[0] ?? "HEAD", depth });
+  if (onelineFlag.enabled) {
+    return ok(
+      commits.map((entry) => `${entry.oid.slice(0, 7)} ${entry.commit.message.split("\n")[0]}`).join("\n") + (commits.length ? "\n" : "")
+    );
+  }
+  return ok(
+    commits.map(
+      (entry) => `commit ${entry.oid}
+Author: ${entry.commit.author.name} <${entry.commit.author.email}>
+
+    ${entry.commit.message.trim().replaceAll("\n", "\n    ")}
+`
+    ).join("\n")
+  );
+}
+async function handleDiff(context, args) {
+  const cachedFlag = flag(args, ["--cached", "--staged"]);
+  rejectOptions(cachedFlag.rest);
+  const dir = await repositoryDir(context.command);
+  const selected = cachedFlag.rest.map((path) => path.replace(/^\.\//, "").replace(/\/$/, ""));
+  const decoder = new TextDecoder();
+  const patch = (filepath, oldBytes, newBytes) => {
+    if (oldBytes.includes(0) || newBytes.includes(0)) {
+      return `Binary files a/${filepath} and b/${filepath} differ
+`;
+    }
+    return createTwoFilesPatch(
+      `a/${filepath}`,
+      `b/${filepath}`,
+      decoder.decode(oldBytes),
+      decoder.decode(newBytes),
+      "",
+      "",
+      { context: 3 }
+    );
+  };
+  const matrix = await git.statusMatrix({
+    fs: context.fs,
+    dir,
+    filepaths: selected.length ? selected : void 0
+  });
+  const stageOids = /* @__PURE__ */ new Map();
+  await git.walk({
+    fs: context.fs,
+    dir,
+    trees: [git.STAGE()],
+    map: async (filepath, [entry]) => {
+      if (entry && await entry.type() !== "tree") stageOids.set(filepath, await entry.oid());
+    }
+  });
+  const head = await git.resolveRef({ fs: context.fs, dir, ref: "HEAD" }).catch(() => void 0);
+  const empty = new Uint8Array();
+  const readStage = async (filepath) => {
+    const oid = stageOids.get(filepath);
+    return oid ? (await git.readBlob({ fs: context.fs, dir, oid })).blob : empty;
+  };
+  const patches = [];
+  for (const [filepath, headStatus, workdirStatus, stageStatus] of matrix) {
+    const changed = cachedFlag.enabled ? headStatus !== stageStatus : workdirStatus !== stageStatus;
+    if (!changed) continue;
+    const oldBytes = cachedFlag.enabled ? head && headStatus !== 0 ? (await git.readBlob({ fs: context.fs, dir, oid: head, filepath })).blob : empty : await readStage(filepath);
+    const newBytes = cachedFlag.enabled ? await readStage(filepath) : workdirStatus === 0 ? empty : await context.command.fs.readFileBuffer(posix3.join(dir, filepath));
+    patches.push(patch(filepath, oldBytes, newBytes));
+  }
+  return ok(patches.join(""));
+}
+async function handleBranch(context, args) {
+  const deleteFlag = flag(args, ["-d", "-D", "--delete"]);
+  rejectOptions(deleteFlag.rest);
+  const dir = await repositoryDir(context.command);
+  if (deleteFlag.enabled) {
+    if (deleteFlag.rest.length !== 1) usage("branch deletion requires one name");
+    await git.deleteBranch({ fs: context.fs, dir, ref: deleteFlag.rest[0] });
+    return ok(`Deleted branch ${deleteFlag.rest[0]}.
+`);
+  }
+  if (deleteFlag.rest.length) {
+    if (deleteFlag.rest.length > 2) usage();
+    await git.branch({
+      fs: context.fs,
+      dir,
+      ref: deleteFlag.rest[0],
+      object: deleteFlag.rest[1]
+    });
+    return ok();
+  }
+  const [branches, current] = await Promise.all([
+    git.listBranches({ fs: context.fs, dir }),
+    git.currentBranch({ fs: context.fs, dir })
+  ]);
+  return ok(
+    branches.map((name) => `${name === current ? "*" : " "} ${name}`).join("\n") + (branches.length ? "\n" : "")
+  );
+}
+async function readCheckoutBlob(context, dir, commitOid, filepath) {
+  let treeOid = (await git.readCommit({ fs: context.fs, dir, oid: commitOid })).commit.tree;
+  const segments = filepath.split("/").filter(Boolean);
+  for (let index = 0; index < segments.length; index++) {
+    const entries = (await git.readTree({ fs: context.fs, dir, oid: treeOid })).tree;
+    const entry = entries.find((candidate) => candidate.path === segments[index]);
+    if (!entry) throw new Error(`path '${filepath}' does not exist in the selected ref`);
+    if (entry.mode === "120000") throw new Error("symbolic links are not supported in the sandbox");
+    if (index === segments.length - 1) {
+      if (entry.type !== "blob") throw new Error(`path '${filepath}' is not a file`);
+      return (await git.readBlob({ fs: context.fs, dir, oid: entry.oid })).blob;
+    }
+    if (entry.type !== "tree") throw new Error(`path '${filepath}' is not a file`);
+    treeOid = entry.oid;
+  }
+  throw new Error("invalid checkout path");
+}
+async function handleCheckout(context, args) {
+  const separator = args.indexOf("--");
+  const commandArgs = separator >= 0 ? args.slice(0, separator) : args;
+  const filepaths = separator >= 0 ? args.slice(separator + 1) : [];
+  const createOpt = optionValue(commandArgs, ["-b"]);
+  const forceFlag = flag(createOpt.rest, ["-f", "--force"]);
+  rejectOptions(forceFlag.rest);
+  const dir = await repositoryDir(context.command);
+  if (filepaths.length) {
+    if (createOpt.value || forceFlag.rest.length > 1) usage();
+    if (filepaths.some((path) => path.startsWith("/") || path.split("/").includes(".."))) {
+      throw new Error("invalid checkout path");
+    }
+    const ref = forceFlag.rest[0] ?? "HEAD";
+    const oid = await git.resolveRef({ fs: context.fs, dir, ref });
+    for (const filepath of filepaths) {
+      const blob = await readCheckoutBlob(context, dir, oid, filepath);
+      await context.command.fs.writeFile(posix3.join(dir, filepath), blob);
+    }
+    return ok();
+  }
+  if (separator >= 0) usage("checkout requires at least one path after --");
+  if (createOpt.value) {
+    if (forceFlag.rest.length > 1) usage();
+    await git.branch({
+      fs: context.fs,
+      dir,
+      ref: createOpt.value,
+      object: forceFlag.rest[0],
+      checkout: true
+    });
+    await git.checkout({ fs: context.fs, dir, ref: createOpt.value, force: forceFlag.enabled });
+    return ok(`Switched to a new branch '${createOpt.value}'
+`);
+  }
+  if (forceFlag.rest.length !== 1) usage("checkout requires one branch or ref");
+  await git.checkout({ fs: context.fs, dir, ref: forceFlag.rest[0], force: forceFlag.enabled });
+  return ok(`Switched to '${forceFlag.rest[0]}'
+`);
+}
+async function handleRemote(context, args) {
+  const dir = await repositoryDir(context.command);
+  if (!args.length || args.length === 1 && args[0] === "-v") {
+    const remotes = await git.listRemotes({ fs: context.fs, dir });
+    const verbose = args[0] === "-v";
+    return ok(
+      remotes.map(
+        ({ remote, url }) => verbose ? `${remote}	${url} (fetch)
+${remote}	${url} (push)` : remote
+      ).join("\n") + (remotes.length ? "\n" : "")
+    );
+  }
+  const [action, name, value, ...rest] = args;
+  if (rest.length || !name) usage();
+  if (action === "add") {
+    if (!value) usage("remote add requires a URL");
+    validateRemoteUrl(value);
+    await git.addRemote({ fs: context.fs, dir, remote: name, url: value });
+    return ok();
+  }
+  if (action === "remove" || action === "rm") {
+    if (value) usage();
+    await git.deleteRemote({ fs: context.fs, dir, remote: name });
+    return ok();
+  }
+  if (action === "get-url") {
+    if (value) usage();
+    const url = await remoteUrl(context, dir, name);
+    return ok(`${url}
+`);
+  }
+  if (action === "set-url") {
+    if (!value) usage();
+    validateRemoteUrl(value);
+    await git.setConfig({ fs: context.fs, dir, path: `remote.${name}.url`, value });
+    return ok();
+  }
+  usage();
+}
+async function handleConfig(context, args) {
+  const globalFlag = flag(args, ["--global"]);
+  const unsetFlag = flag(globalFlag.rest, ["--unset"]);
+  const listFlag = flag(unsetFlag.rest, ["--list", "-l"]);
+  rejectOptions(listFlag.rest);
+  const globalValues = globalFlag.enabled ? await readGlobalConfig(context.command) : void 0;
+  const dir = globalFlag.enabled ? void 0 : await repositoryDir(context.command);
+  if (listFlag.enabled) {
+    if (listFlag.rest.length) usage();
+    if (globalValues) {
+      const output2 = [...globalValues].map(([key2, value2]) => `${key2}=${value2}`).join("\n");
+      return ok(output2 ? `${output2}
+` : "");
+    }
+    const keys = ["user.name", "user.email", "core.repositoryformatversion", "core.bare"];
+    const values = await Promise.all(
+      keys.map(
+        async (key2) => [key2, await git.getConfig({ fs: context.fs, dir, path: key2 })]
+      )
+    );
+    const output = values.filter(([, value2]) => value2 !== void 0).map(([key2, value2]) => `${key2}=${value2}`).join("\n");
+    return ok(output ? `${output}
+` : "");
+  }
+  const [key, value, ...rest] = listFlag.rest;
+  if (rest.length || !key) usage();
+  if (!key.includes(".")) usage("config key must contain a section");
+  if (globalValues) {
+    if (unsetFlag.enabled) {
+      if (value) usage();
+      globalValues.delete(key.toLowerCase());
+      await writeGlobalConfig(context.command, globalValues);
+      return ok();
+    }
+    if (value === void 0) {
+      const found = globalValues.get(key.toLowerCase());
+      return found === void 0 ? { stdout: "", stderr: "", exitCode: 1 } : ok(`${found}
+`);
+    }
+    globalValues.set(key.toLowerCase(), value);
+    await writeGlobalConfig(context.command, globalValues);
+    return ok();
+  }
+  if (unsetFlag.enabled) {
+    if (value) usage();
+    await git.setConfig({ fs: context.fs, dir, path: key, value: void 0 });
+    return ok();
+  }
+  if (value === void 0) {
+    const found = await git.getConfig({ fs: context.fs, dir, path: key });
+    return found === void 0 ? { stdout: "", stderr: "", exitCode: 1 } : ok(`${found}
+`);
+  }
+  await git.setConfig({ fs: context.fs, dir, path: key, value });
+  return ok();
+}
+async function handleClone(context, args) {
+  const branchOpt = optionValue(args, ["-b", "--branch"]);
+  const depthOpt = optionValue(branchOpt.rest, ["--depth"]);
+  const singleFlag = flag(depthOpt.rest, ["--single-branch"]);
+  const noCheckoutFlag = flag(singleFlag.rest, ["--no-checkout"]);
+  rejectOptions(noCheckoutFlag.rest);
+  const [rawUrl, destination, ...rest] = noCheckoutFlag.rest;
+  if (!rawUrl || rest.length) usage("clone requires a URL and optional directory");
+  const url = validateRemoteUrl(rawUrl);
+  const inferred = posix3.basename(new URL(url).pathname).replace(/\.git$/, "") || "repository";
+  const dir = virtualPath(context.command, destination ?? inferred);
+  const depth = positiveInteger(depthOpt.value, "--depth");
+  await git.clone({
+    fs: context.fs,
+    http: context.http,
+    dir,
+    url,
+    ref: branchOpt.value,
+    depth,
+    singleBranch: singleFlag.enabled || Boolean(branchOpt.value),
+    noCheckout: noCheckoutFlag.enabled,
+    onAuth: authFor(context, url)
+  });
+  return ok(`Cloning into '${destination ?? inferred}'...
+`);
+}
+async function handleFetch(context, args) {
+  const depthOpt = optionValue(args, ["--depth"]);
+  rejectOptions(depthOpt.rest);
+  if (depthOpt.rest.length > 2) usage();
+  const dir = await repositoryDir(context.command);
+  const remote = depthOpt.rest[0] ?? "origin";
+  const url = await remoteUrl(context, dir, remote);
+  await git.fetch({
+    fs: context.fs,
+    http: context.http,
+    dir,
+    remote,
+    ref: depthOpt.rest[1],
+    depth: positiveInteger(depthOpt.value, "--depth"),
+    onAuth: authFor(context, url)
+  });
+  return ok();
+}
+async function handlePull(context, args) {
+  const ffFlag = flag(args, ["--ff-only"]);
+  rejectOptions(ffFlag.rest);
+  if (ffFlag.rest.length > 2) usage();
+  const dir = await repositoryDir(context.command);
+  const remote = ffFlag.rest[0] ?? "origin";
+  const url = await remoteUrl(context, dir, remote);
+  await git.pull({
+    fs: context.fs,
+    http: context.http,
+    dir,
+    remote,
+    ref: ffFlag.rest[1],
+    fastForwardOnly: true,
+    // isomorphic-git requires an author even when fastForwardOnly prevents merge commits.
+    author: context.options.author ?? { name: "Ollie Git", email: "git@localhost" },
+    onAuth: authFor(context, url)
+  });
+  return ok("Already up to date or fast-forwarded.\n");
+}
+async function handlePush(context, args) {
+  const forceFlag = flag(args, ["--force", "-f"]);
+  const upstreamFlag = flag(forceFlag.rest, ["--set-upstream", "-u"]);
+  rejectOptions(upstreamFlag.rest);
+  if (upstreamFlag.rest.length > 2) usage();
+  const dir = await repositoryDir(context.command);
+  const remote = upstreamFlag.rest[0] ?? "origin";
+  const ref = upstreamFlag.rest[1] ?? await git.currentBranch({ fs: context.fs, dir });
+  if (!ref) throw new Error("cannot determine branch to push");
+  const url = await remoteUrl(context, dir, remote);
+  const result = await git.push({
+    fs: context.fs,
+    http: context.http,
+    dir,
+    remote,
+    ref,
+    force: forceFlag.enabled,
+    onAuth: authFor(context, url)
+  });
+  if (!result.ok) {
+    const refError = Object.values(result.refs).find((status) => !status.ok)?.error;
+    throw new Error(result.error ?? refError ?? "remote rejected the push");
+  }
+  if (upstreamFlag.enabled) {
+    await git.setConfig({ fs: context.fs, dir, path: `branch.${ref}.remote`, value: remote });
+    await git.setConfig({
+      fs: context.fs,
+      dir,
+      path: `branch.${ref}.merge`,
+      value: `refs/heads/${ref}`
+    });
+  }
+  return ok(`To ${url}
+`);
+}
+var handlers = {
+  init: handleInit,
+  clone: handleClone,
+  status: handleStatus,
+  add: handleAdd,
+  commit: handleCommit,
+  log: handleLog,
+  diff: handleDiff,
+  branch: handleBranch,
+  checkout: handleCheckout,
+  remote: handleRemote,
+  config: handleConfig,
+  fetch: handleFetch,
+  pull: handlePull,
+  push: handlePush
+};
+function redact(message, secrets) {
+  let result = message.replace(/https:\/\/[^\s/@]+@/g, "https://").replaceAll(process.cwd(), "<host>");
+  for (const secret of secrets) {
+    if (secret) result = result.replaceAll(secret, "<redacted>");
+  }
+  return result;
+}
+function createGitCommand(options = {}) {
+  return defineCommand("git", async (args, command) => {
+    const secrets = /* @__PURE__ */ new Set();
+    const safeOptions = options.resolveAuth ? {
+      ...options,
+      resolveAuth: async (url) => {
+        const auth = await options.resolveAuth?.(url);
+        if (auth?.username) secrets.add(auth.username);
+        if (auth?.password) secrets.add(auth.password);
+        return auth;
+      }
+    } : options;
+    try {
+      if (!args.length || args[0] === "help" || args.includes("--help")) {
+        return ok(`usage: git <command> [options]
+
+Supported commands: ${COMMANDS.join(", ")}
+`);
+      }
+      if (args[0] === "--version" || args[0] === "-v") return ok(`${VERSION}
+`);
+      const subcommand = args[0];
+      const handler = subcommand ? handlers[subcommand] : void 0;
+      if (!handler) usage(`'${subcommand ?? ""}' is not a supported git command`);
+      assertNotAborted(command);
+      return await handler(
+        {
+          command,
+          fs: createGitFs(command.fs),
+          http: createGitHttp(command),
+          options: safeOptions
+        },
+        args.slice(1)
+      );
+    } catch (error) {
+      const message = redact(
+        error instanceof Error ? error.message : "unknown Git failure",
+        secrets
+      );
+      const exitCode = error instanceof UsageError ? 129 : /not a git repository|NotFoundError/.test(message) ? 128 : 1;
+      return {
+        stdout: "",
+        stderr: `${error instanceof UsageError ? "error" : "fatal"}: ${message}
+`,
+        exitCode
+      };
+    }
+  });
+}
+
+// src/sandbox/just-bash.ts
+var SANDBOX_WORKSPACE_PATH2 = "/workspace";
+function canonicalizeWorkspaceRoot(workspaceRoot) {
+  const canonicalRoot = realpathSync2(workspaceRoot);
+  if (!statSync2(canonicalRoot).isDirectory()) {
+    throw new Error("The sandbox workspace root must be a directory");
+  }
+  return canonicalRoot;
+}
+function createWorkspaceFs(workspaceRoot, options) {
+  const root = canonicalizeWorkspaceRoot(workspaceRoot);
+  const additionalMounts = validateSandboxMounts(options.mounts ?? []).map((mount) => ({
+    mountPoint: mount.mountPoint,
+    filesystem: new ReadWriteFs({ root: mount.hostPath, allowSymlinks: false })
+  }));
+  return new MountableFs({
+    base: new InMemoryFs(),
+    mounts: [
+      {
+        mountPoint: SANDBOX_WORKSPACE_PATH2,
+        filesystem: new ReadWriteFs({ root, allowSymlinks: false })
+      },
+      ...additionalMounts
+    ]
+  });
+}
+function createJustBash(workspaceRoot, options = {}) {
+  return new Bash({
+    fs: createWorkspaceFs(workspaceRoot, options),
+    cwd: SANDBOX_WORKSPACE_PATH2,
+    env: {
+      HOME: "/home/user",
+      TERM: "xterm-256color"
+    },
+    python: true,
+    javascript: true,
+    customCommands: options.git === false ? [] : [createGitCommand(options.git)],
+    network: {
+      dangerouslyAllowFullInternetAccess: true,
+      maxResponseSize: 100 * 1024 * 1024
+    }
+  });
+}
+async function isJustBashAvailable() {
+  try {
+    const bash = new Bash();
+    await bash.exec("echo ok");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/index.ts
+var packageName = "@getollie/cli";
+var packageVersion = "0.2.0";
+
+// src/doctor.ts
+async function runDoctor(options) {
+  const nodeVersion = process.versions.node;
+  const nodeMajor = Number.parseInt(nodeVersion.split(".")[0] ?? "0", 10);
+  const cwdStats = await stat2(options.cwd).catch(() => null);
+  const cwdAccessible = cwdStats?.isDirectory() ? await access2(options.cwd).then(
+    () => true,
+    () => false
+  ) : false;
+  const justBashAvailable = await isJustBashAvailable();
+  const providerConfigured = options.provider === "openai" ? Boolean(process.env.OPENAI_API_KEY) : false;
+  const report = {
+    packageName,
+    packageVersion,
+    nodeVersion,
+    nodeOk: nodeMajor >= 22,
+    cwd: options.cwd,
+    cwdAccessible,
+    provider: options.provider,
+    model: options.model,
+    providerConfigured,
+    justBashAvailable
+  };
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(report)}
+`);
+  } else {
+    process.stdout.write(`${packageName} ${packageVersion}
+`);
+    process.stdout.write(`node: ${nodeVersion} ${report.nodeOk ? "ok" : "requires >=22"}
+`);
+    process.stdout.write(`workspace: ${options.cwd} ${cwdAccessible ? "ok" : "not accessible"}
+`);
+    process.stdout.write(
+      `provider: ${options.provider} / ${options.model} ${providerConfigured ? "configured" : "missing credentials"}
+`
+    );
+    process.stdout.write(`just-bash: ${justBashAvailable ? "ok" : "unavailable"}
+`);
+  }
+  return report.nodeOk && cwdAccessible && justBashAvailable ? 0 : 1;
+}
+
+// src/exec.ts
+function timeoutSignal(timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  return {
+    signal: controller.signal,
+    cancel: () => clearTimeout(timer)
+  };
+}
+function combineSignals(signals) {
+  const active = signals.filter((signal) => Boolean(signal));
+  if (active.length === 0) {
+    return void 0;
+  }
+  const controller = new AbortController();
+  for (const signal of active) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+async function runExecCommand(cwd, command, options, signal) {
+  const started = Date.now();
+  const timeout = timeoutSignal(options.timeoutMs);
+  const combinedSignal = combineSignals([signal, timeout.signal]);
+  const timedOut = () => timeout.signal.aborted && !signal?.aborted;
+  try {
+    const bash = createJustBash(cwd);
+    const result = await bash.exec(command, { env: options.env, signal: combinedSignal });
+    return {
+      ...result,
+      durationMs: Date.now() - started,
+      timedOut: timedOut()
+    };
+  } catch (error) {
+    if (timedOut()) {
+      return {
+        exitCode: 124,
+        stdout: "",
+        stderr: `Command timed out after ${options.timeoutMs} ms`,
+        env: {},
+        durationMs: Date.now() - started,
+        timedOut: true
+      };
+    }
+    throw error;
+  } finally {
+    timeout.cancel();
+  }
+}
+
+// src/render.ts
+import { Chalk } from "chalk";
+var ELLIPSIS = "\u2026";
+var CENTER_ELLIPSIS = ` ${ELLIPSIS} `;
+function singleRowJson(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(value, (_key, item) => {
+    if (typeof item === "bigint") {
+      return item.toString();
+    }
+    if (item && typeof item === "object") {
+      if (seen.has(item)) {
+        return "[Circular]";
+      }
+      seen.add(item);
+    }
+    return item;
+  }) ?? "null";
+}
+function isCombiningCodePoint(codePoint) {
+  return codePoint >= 768 && codePoint <= 879 || codePoint >= 6832 && codePoint <= 6911 || codePoint >= 7616 && codePoint <= 7679 || codePoint >= 8400 && codePoint <= 8447 || codePoint >= 65056 && codePoint <= 65071;
+}
+function isFullWidthCodePoint(codePoint) {
+  return codePoint >= 4352 && (codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 42191 && codePoint !== 12351 || codePoint >= 44032 && codePoint <= 55203 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127744 && codePoint <= 128591 || codePoint >= 129280 && codePoint <= 129535 || codePoint >= 131072 && codePoint <= 262141);
+}
+function displayWidth(text) {
+  let width = 0;
+  for (const char of text) {
+    const codePoint = char.codePointAt(0) ?? 0;
+    if (codePoint === 0 || codePoint === 8205 || isCombiningCodePoint(codePoint)) {
+      continue;
+    }
+    if (codePoint < 32 || codePoint >= 127 && codePoint < 160) {
+      continue;
+    }
+    width += isFullWidthCodePoint(codePoint) ? 2 : 1;
+  }
+  return width;
+}
+function sliceStartByColumns(text, maxColumns) {
+  let width = 0;
+  let result = "";
+  for (const char of text) {
+    const charWidth = displayWidth(char);
+    if (width + charWidth > maxColumns) {
+      break;
+    }
+    result += char;
+    width += charWidth;
+  }
+  return result;
+}
+function sliceEndByColumns(text, maxColumns) {
+  let width = 0;
+  let result = "";
+  const chars = Array.from(text);
+  for (let index = chars.length - 1; index >= 0; index -= 1) {
+    const char = chars[index] ?? "";
+    const charWidth = displayWidth(char);
+    if (width + charWidth > maxColumns) {
+      break;
+    }
+    result = `${char}${result}`;
+    width += charWidth;
+  }
+  return result;
+}
+function ellipsizeToColumnParts(text, maxColumns) {
+  if (maxColumns === void 0 || displayWidth(text) <= maxColumns) {
+    return { head: text, marker: "", tail: "" };
+  }
+  if (maxColumns <= 0) {
+    return { head: "", marker: "", tail: "" };
+  }
+  if (maxColumns === 1) {
+    return { head: "", marker: ELLIPSIS, tail: "" };
+  }
+  const marker = maxColumns >= displayWidth(CENTER_ELLIPSIS) ? CENTER_ELLIPSIS : ELLIPSIS;
+  const targetWidth = maxColumns - displayWidth(marker);
+  const head = sliceStartByColumns(text, Math.ceil(targetWidth / 2));
+  const tail = sliceEndByColumns(text, targetWidth - displayWidth(head));
+  return { head, marker, tail };
+}
+function getStderrColumns() {
+  return process.stderr.columns && process.stderr.columns > 0 ? process.stderr.columns : void 0;
+}
+function resolveToolRowColumns(columns) {
+  return Math.min(columns ?? 120, 120);
+}
+function formatToolRow(options) {
+  const prefix = `${options.symbol} ${options.toolName} `;
+  const maxPayloadColumns = Math.max(1, options.columns - displayWidth(prefix));
+  return ellipsizeToColumnParts(singleRowJson(options.value), maxPayloadColumns);
+}
+function colorToolRow(c, row) {
+  return `${c.dim(row.head)}${c.yellow(row.marker)}${c.dim(row.tail)}`;
+}
+function toolSymbol(arrow, source) {
+  return source === "delegate" ? `  \u21B3 ${arrow}` : arrow;
+}
+function createRenderer(options) {
+  if (options.ndjson) {
+    return {
+      render(event) {
+        process.stdout.write(`${singleRowJson(event)}
+`);
+      }
+    };
+  }
+  const c = new Chalk({ level: options.color ? 1 : 0 });
+  const columns = resolveToolRowColumns(options.columns ?? getStderrColumns());
+  return {
+    render(event) {
+      switch (event.type) {
+        case "text":
+          process.stdout.write(event.text);
+          break;
+        case "tool-call": {
+          const symbol = toolSymbol("\u2192", event.source);
+          process.stderr.write(
+            `${c.dim(symbol)} ${c.cyan(event.toolName)} ${colorToolRow(
+              c,
+              formatToolRow({
+                symbol,
+                toolName: event.toolName,
+                value: event.input,
+                columns
+              })
+            )}
+`
+          );
+          break;
+        }
+        case "tool-result": {
+          const symbol = toolSymbol("\u2190", event.source);
+          process.stderr.write(
+            `${c.dim(symbol)} ${c.green(event.toolName)} ${colorToolRow(
+              c,
+              formatToolRow({
+                symbol,
+                toolName: event.toolName,
+                value: event.output,
+                columns
+              })
+            )}
+`
+          );
+          break;
+        }
+        case "error":
+          process.stderr.write(`${c.red("error:")} ${event.message}
+`);
+          break;
+        case "done":
+          process.stderr.write(c.dim("\n[done]\n"));
+          break;
+      }
+    }
+  };
+}
+
+// src/runner.ts
+import { stepCountIs as stepCountIs2, streamText } from "ai";
+
+// src/executor/controller.ts
+var ExecutorController = class {
+  constructor(provider, delegator) {
+    this.provider = provider;
+    this.delegator = delegator;
+  }
+  provider;
+  delegator;
+  #session;
+  #creatingSession;
+  #running = false;
+  #disposed = false;
+  async delegateTask(task, signal) {
+    if (this.#disposed) throw new Error("Executor controller has been disposed");
+    if (this.#running) throw new Error("Executor delegation is already in progress");
+    signal?.throwIfAborted();
+    this.#running = true;
+    let session;
+    let result;
+    let taskError;
+    try {
+      session = await this.#getSession(signal);
+      await session.resume(signal);
+      result = await this.delegator.runTask({ session, task, signal });
+    } catch (error) {
+      taskError = error;
+    }
+    let pauseError;
+    try {
+      await session?.pause(signal?.aborted ? void 0 : signal);
+    } catch (error) {
+      pauseError = error;
+    } finally {
+      this.#running = false;
+    }
+    if (taskError !== void 0) throw taskError;
+    if (pauseError !== void 0) throw pauseError;
+    if (!result) throw new Error("Delegated task completed without a result");
+    return result;
+  }
+  async dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    const session = this.#session ?? await this.#creatingSession?.catch(() => void 0);
+    await session?.dispose();
+  }
+  async #getSession(signal) {
+    if (this.#session) return this.#session;
+    if (!this.#creatingSession) {
+      this.#creatingSession = this.provider.createSession({ signal }).then((session) => {
+        this.#session = session;
+        return session;
+      });
+    }
+    return this.#creatingSession;
+  }
+};
+
+// src/executor/daytona.ts
+import { randomUUID } from "crypto";
+import { mkdir, readdir, readFile, rm, stat as stat3, writeFile } from "fs/promises";
+import { dirname, isAbsolute, relative, resolve as resolve3, sep } from "path";
+import {
+  Daytona,
+  DaytonaProcessExecutionTimeoutError
+} from "@daytona/sdk";
+var DEFAULT_REMOTE_WORKSPACE = "/workspace";
+var DEFAULT_TTL_MINUTES = 10;
+function timeoutSeconds(timeoutMs) {
+  return Math.max(1, Math.ceil(timeoutMs / 1e3));
+}
+function abortable(promise, signal) {
+  signal?.throwIfAborted();
+  if (!signal) return promise;
+  return new Promise((resolvePromise, reject) => {
+    const onAbort = () => reject(signal.reason ?? new Error("Daytona operation aborted"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolvePromise(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+async function listLocalFiles(root) {
+  const files = /* @__PURE__ */ new Map();
+  async function visit(directory) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      const absolutePath = resolve3(directory, entry.name);
+      if (entry.isDirectory()) {
+        await visit(absolutePath);
+      } else if (entry.isFile()) {
+        const path = relative(root, absolutePath).split(sep).join("/");
+        files.set(path, (await stat3(absolutePath)).size);
+      }
+    }
+  }
+  await visit(root);
+  return files;
+}
+var DaytonaSandbox = class {
+  #sandbox;
+  #workspacePath;
+  #commandTimeoutMs;
+  #signal;
+  #disposed = false;
+  constructor(sandbox, options) {
+    this.#sandbox = sandbox;
+    this.#workspacePath = options.workspacePath;
+    this.#commandTimeoutMs = options.commandTimeoutMs;
+    this.#signal = options.signal;
+  }
+  async executeCommand(command) {
+    this.#assertActive();
+    this.#signal?.throwIfAborted();
+    const marker = `__OLLIE_STDERR_${randomUUID()}__`;
+    const stderrPath = `/tmp/ollie-stderr-${randomUUID()}`;
+    const wrapped = `( ${command}
+) 2>${shellQuote(stderrPath)}; ollie_code=$?; printf '
+${marker}
+'; base64 < ${shellQuote(stderrPath)}; rm -f ${shellQuote(stderrPath)}; exit $ollie_code`;
+    try {
+      const response = await abortable(
+        this.#sandbox.process.executeCommand(
+          wrapped,
+          this.#workspacePath,
+          void 0,
+          timeoutSeconds(this.#commandTimeoutMs)
+        ),
+        this.#signal
+      );
+      const separator = `
+${marker}
+`;
+      const markerIndex = response.result.lastIndexOf(separator);
+      if (markerIndex < 0) {
+        return { exitCode: response.exitCode, stdout: response.result, stderr: "" };
+      }
+      const encodedStderr = response.result.slice(markerIndex + separator.length).trim();
+      return {
+        exitCode: response.exitCode,
+        stdout: response.result.slice(0, markerIndex),
+        stderr: encodedStderr ? Buffer.from(encodedStderr, "base64").toString("utf8") : ""
+      };
+    } catch (error) {
+      if (error instanceof DaytonaProcessExecutionTimeoutError) {
+        return {
+          exitCode: 124,
+          stdout: "",
+          stderr: `Command timed out after ${this.#commandTimeoutMs} ms`
+        };
+      }
+      throw error;
+    }
+  }
+  async readFile(path) {
+    this.#assertActive();
+    const content = await this.#sandbox.fs.downloadFile(this.#resolvePath(path));
+    return content.toString("utf8");
+  }
+  async writeFiles(files) {
+    this.#assertActive();
+    for (const file of files) {
+      const target = this.#resolvePath(file.path);
+      await this.#sandbox.process.executeCommand(`mkdir -p ${shellQuote(dirname(target))}`);
+      await this.#sandbox.fs.uploadFile(Buffer.from(file.content), target);
+    }
+  }
+  dispose() {
+    this.#disposed = true;
+  }
+  #resolvePath(path) {
+    const target = isAbsolute(path) ? resolve3(path) : resolve3(this.#workspacePath, path);
+    if (target !== this.#workspacePath && !target.startsWith(`${this.#workspacePath}/`)) {
+      throw new Error(`Path is outside the Daytona workspace: ${path}`);
+    }
+    return target;
+  }
+  #assertActive() {
+    if (this.#disposed) throw new Error("Daytona executor session has been disposed");
+  }
+};
+var DaytonaWorkspaceSynchronizer = class {
+  #cwd;
+  #remoteWorkspacePath;
+  #sandbox;
+  #knownFiles = /* @__PURE__ */ new Set();
+  constructor(cwd, remoteWorkspacePath, sandbox) {
+    this.#cwd = resolve3(cwd);
+    this.#remoteWorkspacePath = remoteWorkspacePath;
+    this.#sandbox = sandbox;
+  }
+  async syncToExecutor(signal) {
+    signal?.throwIfAborted();
+    const prepareResult = await abortable(
+      this.#sandbox.process.executeCommand(`mkdir -p ${shellQuote(this.#remoteWorkspacePath)}`),
+      signal
+    );
+    if (prepareResult.exitCode !== 0) {
+      throw new Error(
+        `Failed to create Daytona workspace ${this.#remoteWorkspacePath}: ${prepareResult.result}`
+      );
+    }
+    const localFiles = await listLocalFiles(this.#cwd);
+    let filesCreated = 0;
+    let filesUpdated = 0;
+    let filesDeleted = 0;
+    let bytesTransferred = 0;
+    for (const path of this.#knownFiles) {
+      if (localFiles.has(path)) continue;
+      await abortable(
+        this.#sandbox.fs.deleteFile(this.#remotePath(path)).catch(() => void 0),
+        signal
+      );
+      filesDeleted++;
+    }
+    for (const [path, size] of localFiles) {
+      signal?.throwIfAborted();
+      await abortable(
+        this.#sandbox.fs.uploadFile(resolve3(this.#cwd, path), this.#remotePath(path)),
+        signal
+      );
+      if (this.#knownFiles.has(path)) filesUpdated++;
+      else filesCreated++;
+      bytesTransferred += size;
+    }
+    this.#knownFiles = new Set(localFiles.keys());
+    return this.#result(filesCreated, filesUpdated, filesDeleted, bytesTransferred);
+  }
+  async syncToLocal(signal) {
+    signal?.throwIfAborted();
+    const response = await abortable(
+      this.#sandbox.process.executeCommand(
+        "find . -type f -print0 | base64 -w0",
+        this.#remoteWorkspacePath
+      ),
+      signal
+    );
+    if (response.exitCode !== 0) {
+      throw new Error(`Failed to enumerate Daytona workspace files: ${response.result}`);
+    }
+    const decoded = response.result.trim() ? Buffer.from(response.result.trim(), "base64").toString("utf8") : "";
+    const remoteFiles = new Set(
+      decoded.split("\0").filter(Boolean).map((path) => path.startsWith("./") ? path.slice(2) : path)
+    );
+    let filesCreated = 0;
+    let filesUpdated = 0;
+    let filesDeleted = 0;
+    let bytesTransferred = 0;
+    for (const path of this.#knownFiles) {
+      if (remoteFiles.has(path)) continue;
+      await rm(resolve3(this.#cwd, path), { force: true });
+      filesDeleted++;
+    }
+    for (const path of remoteFiles) {
+      signal?.throwIfAborted();
+      const localPath = this.#localPath(path);
+      const existed = await stat3(localPath).then(
+        () => true,
+        () => false
+      );
+      const content = await abortable(
+        this.#sandbox.fs.downloadFile(this.#remotePath(path)),
+        signal
+      );
+      await mkdir(dirname(localPath), { recursive: true });
+      const previous = existed ? await readFile(localPath) : void 0;
+      if (!previous?.equals(content)) {
+        await writeFile(localPath, content);
+        if (existed) filesUpdated++;
+        else filesCreated++;
+        bytesTransferred += content.byteLength;
+      }
+    }
+    this.#knownFiles = remoteFiles;
+    return this.#result(filesCreated, filesUpdated, filesDeleted, bytesTransferred);
+  }
+  #remotePath(path) {
+    return `${this.#remoteWorkspacePath}/${path}`;
+  }
+  #localPath(path) {
+    const target = resolve3(this.#cwd, path);
+    if (target !== this.#cwd && !target.startsWith(`${this.#cwd}${sep}`)) {
+      throw new Error(`Daytona returned a path outside the workspace: ${path}`);
+    }
+    return target;
+  }
+  #result(filesCreated, filesUpdated, filesDeleted, bytesTransferred) {
+    return {
+      status: filesCreated || filesUpdated || filesDeleted || bytesTransferred ? "synchronized" : "no-changes",
+      filesCreated,
+      filesUpdated,
+      filesDeleted,
+      bytesTransferred
+    };
+  }
+};
+var DaytonaExecutorSession = class {
+  sandbox;
+  context;
+  #remote;
+  #synchronizer;
+  #stopped = false;
+  #disposed = false;
+  constructor(remote, options, signal) {
+    const workspacePath = options.remoteWorkspacePath ?? DEFAULT_REMOTE_WORKSPACE;
+    this.#remote = remote;
+    this.#synchronizer = new DaytonaWorkspaceSynchronizer(options.cwd, workspacePath, remote);
+    this.sandbox = new DaytonaSandbox(remote, {
+      workspacePath,
+      commandTimeoutMs: options.commandTimeoutMs,
+      signal
+    });
+    this.context = {
+      kind: "daytona",
+      workspacePath,
+      isolated: true,
+      networkAccess: "full"
+    };
+  }
+  async resume(signal) {
+    this.#assertActive();
+    signal?.throwIfAborted();
+    if (this.#stopped) {
+      await abortable(this.#remote.start(), signal);
+      this.#stopped = false;
+    }
+    await this.syncWorkspace({ destination: "executor", signal });
+  }
+  async pause(signal) {
+    this.#assertActive();
+    signal?.throwIfAborted();
+    await this.syncWorkspace({ destination: "local", signal });
+    await abortable(this.#remote.stop(), signal);
+    this.#stopped = true;
+  }
+  async syncWorkspace(options) {
+    this.#assertActive();
+    return options.destination === "executor" ? this.#synchronizer.syncToExecutor(options.signal) : this.#synchronizer.syncToLocal(options.signal);
+  }
+  async dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.sandbox.dispose();
+    await this.#remote.delete(60, true);
+  }
+  #assertActive() {
+    if (this.#disposed) throw new Error("Daytona executor session has been disposed");
+  }
+};
+var DaytonaExecutorProvider = class {
+  systemPrompt = `Executor-backed delegation:
+- The delegateTask tool starts a fresh delegated agent with native workspace tools in an isolated Daytona sandbox.
+- Use delegateTask when the task requires unavailable executables, package managers, full system tooling, or native test/build commands.
+- The delegated agent cannot delegate further. Its trajectory and exact final summary are returned to you.
+- The Daytona workspace uses a provider-selected writable path that differs from your /workspace path. In delegated task descriptions, say "the workspace root" and do not hardcode /workspace; the child receives its actual workspace path.
+- One remote executor session is reused for this run. Workspace changes are synchronized back before delegateTask returns and are then visible through your workspace tools.
+- Remote startup and workspace transfer have overhead, so delegate bounded, substantial work rather than individual commands.
+- Do not claim delegated work succeeded unless the returned trajectory or summary confirms it.`;
+  #options;
+  #client;
+  constructor(options) {
+    this.#options = options;
+    this.#client = options.client;
+  }
+  async createSession({ signal }) {
+    signal?.throwIfAborted();
+    const client = this.#client ?? new Daytona();
+    const remote = await abortable(
+      client.create(
+        {
+          ...this.#options.snapshot ? { snapshot: this.#options.snapshot } : {},
+          autoStopInterval: 0,
+          autoDeleteInterval: 3,
+          ttlMinutes: this.#options.ttlMinutes ?? DEFAULT_TTL_MINUTES,
+          labels: { managedBy: "ollie" }
+        },
+        { timeout: 120 }
+      ),
+      signal
+    );
+    try {
+      const workDir = await abortable(remote.getWorkDir(), signal);
+      if (!workDir) throw new Error("Daytona did not report a writable working directory");
+      const remoteWorkspacePath = this.#options.remoteWorkspacePath ?? `${workDir.replace(/\/+$/, "")}/ollie-workspace`;
+      return new DaytonaExecutorSession(remote, { ...this.#options, remoteWorkspacePath }, signal);
+    } catch (error) {
+      await remote.delete(60, true).catch(() => void 0);
+      throw error;
+    }
+  }
+};
+
+// src/executor/delegator.ts
+import { generateText, stepCountIs } from "ai";
+
+// src/prompt.ts
+function buildSystemPrompt(options) {
+  const executorSection = options.executorInstructions ? `
+
+${options.executorInstructions}` : "";
+  return `You are Terminus, a concise one-shot CLI evaluation agent inspired by Harbor Terminus-2.
+
+Terminus-2 spirit:
+- Prefer terminal-centric operation through the bash tool.
+- Treat bash as the primary terminal environment: inspect files, list directories, search text, run tests, and gather state by issuing shell commands.
+- Operate autonomously and finish the user's task in this single run.
+- Do not ask for interactive confirmation or user input during execution.
+- Prefer concrete terminal inspection over speculation. Verify facts through shell output before claiming them.
+- Keep actions minimal, bounded, and relevant to the task.
+- Explain failures clearly and recover where practical.
+- Do not claim a command, file observation, test result, or search result succeeded unless shell output confirms it.
+- Summarize final findings and important command results clearly.
+
+Runtime context:
+- Working directory: ${SANDBOX_WORKSPACE_PATH2}
+- Current time: ${options.now.toISOString()}
+- Maximum model/tool steps: ${options.maxSteps}
+- Per-command timeout: ${options.commandTimeoutMs} ms
+
+Environment capabilities and limitations:
+- This is a restricted Bash environment. Only the provided built-in commands and Ollie's Git command can run.
+- Arbitrary executables and package managers such as node, npm, pnpm, npx, bun, deno, and system Python are unavailable; downloading a binary does not make it executable.
+- Use python/python3 (CPython compiled to WebAssembly) or js-exec (QuickJS) for supported scripting. They are not full Python or Node.js environments and cannot install or import arbitrary packages.
+- Common built-ins include find, rg, grep, sed, awk, jq, yq, curl, diff, tar, and sqlite3. Run help or <command> --help when uncertain; do not repeatedly probe unavailable commands.
+- Shell state is isolated per bash tool call: cd, exported variables, aliases, and functions do not carry into the next call. Combine dependent shell-state operations in one call, or pass explicit paths.
+- There is no process/job control or background execution. Shell arithmetic is limited to signed 32-bit integers, and loops, recursion, command counts, runtime, and output are bounded.
+- The environment defaults to UTC. Symbolic links are disabled.
+- Full HTTP(S) network access is enabled through curl and compatible commands. Network requests can have permanent external side effects.${executorSection}
+
+Tool policy:
+- There is no approval flow. Tool calls execute automatically.
+- Git supports a practical subset of commands. Hooks, submodules, signing, SSH remotes, editors, pagers, and advanced options are unavailable.
+- A successful git push or other mutating network request changes the remote permanently and is allowed only when explicitly requested by the user.
+- Avoid destructive actions unless the user's task explicitly requires them.`;
+}
+function buildDelegatedSystemPrompt(options) {
+  const executionBoundary = options.context.isolated ? "Commands run natively inside an isolated remote environment." : "Commands run natively with the current user's permissions and are not isolated.";
+  return `You are Ollie's delegated execution agent. Complete one bounded task using native workspace tools.
+
+Runtime context:
+- Workspace root: ${options.context.workspacePath}
+- Current time: ${options.now.toISOString()}
+- Maximum model/tool steps: ${options.maxSteps}
+- Per-command timeout: ${options.commandTimeoutMs} ms
+- ${executionBoundary}
+
+Operating rules:
+- Start at the workspace root and use relative paths for workspace files.
+- Inspect the relevant state before making changes.
+- Keep changes minimal and directly related to the delegated task.
+- Run appropriate native checks or tests and report their actual results.
+- Do not delegate work and do not attempt to synchronize the workspace; neither capability is available.
+- Avoid destructive or permanent external actions unless the delegated task explicitly requires them.
+- Finish with a concise text summary describing what you did, what changed, and how you verified it. This final text block is returned verbatim to the parent agent.`;
+}
+
+// src/tools.ts
+import { createBashTool } from "bash-tool";
+async function createWorkspaceTools(options) {
+  const toolkit = await createBashTool({
+    sandbox: options.sandbox,
+    destination: options.destination,
+    maxOutputLength: options.maxOutputBytes,
+    extraInstructions: options.extraInstructions
+  });
+  return toolkit.tools;
+}
+async function createTools(options) {
+  return createWorkspaceTools({
+    sandbox: createJustBash(options.cwd, { mounts: options.mounts }),
+    destination: SANDBOX_WORKSPACE_PATH2,
+    maxOutputBytes: options.maxOutputBytes,
+    extraInstructions: "Use bash commands to inspect files, search, run tests, and gather terminal state. Sandbox-native git is available; local Git changes persist in the workspace, and git push has permanent remote effects, so destructive actions and pushes must only be used when explicitly requested. Keep commands bounded."
+  });
+}
+
+// src/executor/delegator.ts
+var ModelTaskDelegator = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async runTask({
+    session,
+    task,
+    signal
+  }) {
+    const instructions = buildDelegatedSystemPrompt({
+      now: this.options.now?.() ?? /* @__PURE__ */ new Date(),
+      maxSteps: this.options.maxSteps,
+      commandTimeoutMs: this.options.commandTimeoutMs,
+      context: session.context
+    });
+    const tools = await createWorkspaceTools({
+      sandbox: session.sandbox,
+      destination: session.context.workspacePath,
+      maxOutputBytes: this.options.maxOutputBytes,
+      extraInstructions: "Use the native workspace tools to complete the delegated task. Start at the workspace root, use relative paths, keep changes focused, and verify the result before reporting it."
+    });
+    const result = await generateText({
+      model: this.options.model,
+      instructions,
+      prompt: task,
+      tools,
+      stopWhen: stepCountIs(this.options.maxSteps),
+      abortSignal: signal,
+      maxRetries: 1,
+      onStepFinish: async (step) => {
+        for (const toolCall of step.toolCalls) {
+          await this.options.onEvent?.({
+            type: "tool-call",
+            toolName: toolCall.toolName,
+            input: toolCall.input,
+            source: "delegate"
+          });
+        }
+        for (const toolResult of step.toolResults) {
+          await this.options.onEvent?.({
+            type: "tool-result",
+            toolName: toolResult.toolName,
+            output: toolResult.output,
+            source: "delegate"
+          });
+        }
+      }
+    });
+    const finalTextParts = result.finalStep.content.filter(
+      (part) => part.type === "text"
+    );
+    const summary = finalTextParts.at(-1)?.text;
+    if (summary === void 0) {
+      throw new Error("Delegated agent did not return a final text summary");
+    }
+    const trajectory = [
+      { role: "system", content: instructions },
+      { role: "user", content: task },
+      ...result.responseMessages
+    ];
+    return { trajectory, summary };
+  }
+};
+
+// src/executor/local.ts
+import { spawn } from "child_process";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
+var LocalSandbox = class {
+  #cwd;
+  #commandTimeoutMs;
+  #env;
+  #signal;
+  #processes = /* @__PURE__ */ new Set();
+  #disposed = false;
+  constructor(options, signal) {
+    this.#cwd = resolve4(options.cwd);
+    this.#commandTimeoutMs = options.commandTimeoutMs;
+    this.#env = options.env ?? process.env;
+    this.#signal = signal;
+  }
+  async executeCommand(command) {
+    this.#assertActive();
+    this.#signal?.throwIfAborted();
+    return new Promise((resolveResult, reject) => {
+      const child = spawn("/bin/sh", ["-lc", command], {
+        cwd: this.#cwd,
+        env: this.#env,
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      this.#processes.add(child);
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      let abortReason;
+      let forceTimer;
+      let settled = false;
+      const finish = (callback) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (forceTimer) clearTimeout(forceTimer);
+        this.#signal?.removeEventListener("abort", onAbort);
+        this.#processes.delete(child);
+        callback();
+      };
+      const terminate = (signal) => {
+        if (!child.pid) return;
+        try {
+          process.kill(-child.pid, signal);
+        } catch {
+          child.kill(signal);
+        }
+      };
+      const beginTermination = () => {
+        terminate("SIGTERM");
+        forceTimer = setTimeout(() => terminate("SIGKILL"), 100);
+        forceTimer.unref();
+      };
+      const onAbort = () => {
+        abortReason = this.#signal?.reason ?? new Error("Executor command aborted");
+        beginTermination();
+      };
+      const timer = setTimeout(() => {
+        timedOut = true;
+        beginTermination();
+      }, this.#commandTimeoutMs);
+      child.stdout?.setEncoding("utf8");
+      child.stderr?.setEncoding("utf8");
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk;
+      });
+      child.once("error", (error) => finish(() => reject(error)));
+      child.once("close", (code, signal) => {
+        finish(() => {
+          if (abortReason !== void 0) {
+            reject(abortReason);
+            return;
+          }
+          if (timedOut) {
+            resolveResult({
+              exitCode: 124,
+              stdout,
+              stderr: `${stderr}${stderr ? "\n" : ""}Command timed out after ${this.#commandTimeoutMs} ms`
+            });
+            return;
+          }
+          resolveResult({
+            exitCode: code ?? (signal ? 128 : 1),
+            stdout,
+            stderr
+          });
+        });
+      });
+      this.#signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  async readFile(path) {
+    this.#assertActive();
+    return readFile2(this.#resolvePath(path), "utf8");
+  }
+  async writeFiles(files) {
+    this.#assertActive();
+    await Promise.all(
+      files.map(async ({ path, content }) => {
+        const target = this.#resolvePath(path);
+        await mkdir2(dirname2(target), { recursive: true });
+        await writeFile2(target, content);
+      })
+    );
+  }
+  dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    for (const child of this.#processes) {
+      if (!child.pid) continue;
+      try {
+        process.kill(-child.pid, "SIGTERM");
+      } catch {
+        child.kill("SIGTERM");
+      }
+    }
+    this.#processes.clear();
+  }
+  #resolvePath(path) {
+    return isAbsolute2(path) ? path : resolve4(this.#cwd, path);
+  }
+  #assertActive() {
+    if (this.#disposed) throw new Error("Local executor session has been disposed");
+  }
+};
+var LocalExecutorSession = class {
+  sandbox;
+  context;
+  #disposed = false;
+  constructor(options, signal) {
+    const workspacePath = resolve4(options.cwd);
+    this.sandbox = new LocalSandbox(options, signal);
+    this.context = {
+      kind: "local",
+      workspacePath,
+      isolated: false,
+      networkAccess: "full"
+    };
+  }
+  async resume(signal) {
+    this.#assertActive();
+    signal?.throwIfAborted();
+  }
+  async pause(signal) {
+    this.#assertActive();
+    signal?.throwIfAborted();
+  }
+  async dispose() {
+    if (this.#disposed) return;
+    this.#disposed = true;
+    this.sandbox.dispose();
+  }
+  #assertActive() {
+    if (this.#disposed) throw new Error("Local executor session has been disposed");
+  }
+};
+var LocalExecutorProvider = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  systemPrompt = `Executor-backed delegation:
+- The delegateTask tool starts a fresh delegated agent with native workspace tools at the current local workspace root.
+- Use delegateTask when the task requires unavailable executables, package managers, full system tooling, or native test/build commands.
+- Native execution runs with the current user's permissions and is not isolated. Delegate only bounded, task-relevant work.
+- The delegated agent cannot delegate further. Its trajectory and exact final summary are returned to you.
+- One executor session is reused for this run. Because the local executor shares the workspace, its file changes are immediately visible through your workspace tools.
+- Do not claim delegated work succeeded unless the returned trajectory or summary confirms it.`;
+  async createSession({ signal }) {
+    signal?.throwIfAborted();
+    return new LocalExecutorSession(this.options, signal);
+  }
+};
+
+// src/executor/tools.ts
+import { jsonSchema, tool } from "ai";
+function createExecutorTools(controller) {
+  return {
+    delegateTask: tool({
+      description: "Delegate one bounded task to a fresh agent with native workspace tools in the configured execution environment.",
+      inputSchema: jsonSchema({
+        type: "object",
+        additionalProperties: false,
+        required: ["task"],
+        properties: {
+          task: {
+            type: "string",
+            minLength: 1,
+            description: "A complete, self-contained description of the task to perform"
+          }
+        }
+      }),
+      execute: async ({ task }, { abortSignal }) => {
+        const trimmedTask = task.trim();
+        if (!trimmedTask) throw new Error("Delegated task must not be empty");
+        return controller.delegateTask(trimmedTask, abortSignal);
+      }
+    })
+  };
+}
+
+// src/provider.ts
+import { createOpenAI } from "@ai-sdk/openai";
+function createLanguageModel({
+  provider,
+  model,
+  env = process.env
+}) {
+  if (provider !== "openai") {
+    throw new CliError(
+      `Unsupported provider: ${provider}. The reference implementation currently supports openai.`
+    );
+  }
+  if (!env.OPENAI_API_KEY) {
+    throw new CliError("OPENAI_API_KEY is required when using the openai provider.");
+  }
+  const openai = createOpenAI({ apiKey: env.OPENAI_API_KEY });
+  return openai(model);
+}
+
+// src/runner.ts
+function createExecutorProvider(options) {
+  switch (options.executor) {
+    case "none":
+      return void 0;
+    case "local":
+      return new LocalExecutorProvider({
+        cwd: options.cwd,
+        commandTimeoutMs: options.commandTimeoutMs
+      });
+    case "daytona":
+      return new DaytonaExecutorProvider({
+        cwd: options.cwd,
+        commandTimeoutMs: options.commandTimeoutMs,
+        snapshot: process.env.OLLIE_DAYTONA_SNAPSHOT
+      });
+  }
+}
+async function runOneShot(options) {
+  let executorController;
+  try {
+    const model = createLanguageModel({
+      provider: options.provider,
+      model: options.model
+    });
+    const workspaceTools = await createTools({
+      cwd: options.cwd,
+      mounts: options.mounts,
+      maxOutputBytes: options.maxOutputBytes
+    });
+    const executorProvider = createExecutorProvider(options);
+    if (executorProvider) {
+      executorController = new ExecutorController(
+        executorProvider,
+        new ModelTaskDelegator({
+          model,
+          maxSteps: options.maxSteps,
+          maxOutputBytes: options.maxOutputBytes,
+          commandTimeoutMs: options.commandTimeoutMs,
+          onEvent: options.onEvent
+        })
+      );
+    }
+    const tools = {
+      ...workspaceTools,
+      ...executorController ? createExecutorTools(executorController) : {}
+    };
+    const result = streamText({
+      model,
+      tools,
+      instructions: buildSystemPrompt({
+        now: /* @__PURE__ */ new Date(),
+        maxSteps: options.maxSteps,
+        commandTimeoutMs: options.commandTimeoutMs,
+        executorInstructions: executorProvider?.systemPrompt
+      }),
+      prompt: options.prompt,
+      stopWhen: stepCountIs2(options.maxSteps),
+      abortSignal: options.signal,
+      maxRetries: 1
+    });
+    for await (const part of result.stream) {
+      switch (part.type) {
+        case "text-delta":
+          await options.onEvent({ type: "text", text: part.text });
+          break;
+        case "tool-call":
+          await options.onEvent({ type: "tool-call", toolName: part.toolName, input: part.input });
+          break;
+        case "tool-result":
+          await options.onEvent({
+            type: "tool-result",
+            toolName: part.toolName,
+            output: part.output
+          });
+          break;
+        case "tool-error":
+          await options.onEvent({
+            type: "error",
+            message: `${part.toolName}: ${getErrorMessage(part.error)}`
+          });
+          break;
+        case "error":
+          await options.onEvent({ type: "error", message: getErrorMessage(part.error) });
+          break;
+        case "finish":
+          await options.onEvent({ type: "done", usage: part.totalUsage });
+          break;
+      }
+    }
+    return 0;
+  } catch (error) {
+    if (options.signal?.aborted) {
+      await options.onEvent({ type: "error", message: "aborted" });
+      return 130;
+    }
+    await options.onEvent({ type: "error", message: getErrorMessage(error) });
+    return 1;
+  } finally {
+    await executorController?.dispose();
+  }
+}
+
+// src/sandbox/runtime.ts
+import { once } from "events";
+import { posix as posix4 } from "path";
+import { createInterface } from "readline";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseRequest(line) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    throw new Error("Invalid JSON request");
+  }
+  if (!isRecord(value)) {
+    throw new Error("Request must be a JSON object");
+  }
+  if (typeof value.id !== "string" && typeof value.id !== "number") {
+    throw new Error("Request id must be a string or number");
+  }
+  if (value.method !== "exec" && value.method !== "readFile" && value.method !== "writeFile") {
+    throw new Error("Unknown worker method");
+  }
+  if (!isRecord(value.params)) {
+    throw new Error("Request params must be a JSON object");
+  }
+  return {
+    id: value.id,
+    method: value.method,
+    params: value.params
+  };
+}
+function requireString(params, name) {
+  const value = params[name];
+  if (typeof value !== "string") {
+    throw new Error(`Parameter ${name} must be a string`);
+  }
+  return value;
+}
+function validateVirtualPath(path) {
+  if (!posix4.isAbsolute(path) || path.includes("\\") || path.includes("\0") || posix4.normalize(path) !== path || path.split("/").some((component) => component === "." || component === "..")) {
+    throw new Error("Path must be a normalized absolute virtual path");
+  }
+  return path;
+}
+function requestIdFromLine(line) {
+  try {
+    const value = JSON.parse(line);
+    if (isRecord(value) && (typeof value.id === "string" || typeof value.id === "number")) {
+      return value.id;
+    }
+  } catch {
+  }
+  return null;
+}
+function safeErrorMessage(error, workspaceRoot) {
+  const message = error instanceof Error ? error.message : "Worker operation failed";
+  return message.split(workspaceRoot).join("<workspace>");
+}
+async function handleWorkerLine(bash, line, workspaceRoot) {
+  const fallbackId = requestIdFromLine(line);
+  try {
+    const request = parseRequest(line);
+    switch (request.method) {
+      case "exec": {
+        const command = requireString(request.params, "command");
+        const result = await bash.exec(command);
+        return {
+          id: request.id,
+          result: {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode
+          }
+        };
+      }
+      case "readFile": {
+        const path = validateVirtualPath(requireString(request.params, "path"));
+        return { id: request.id, result: await bash.fs.readFile(path) };
+      }
+      case "writeFile": {
+        const path = validateVirtualPath(requireString(request.params, "path"));
+        const content = requireString(request.params, "content");
+        await bash.fs.writeFile(path, content);
+        return { id: request.id, result: null };
+      }
+    }
+  } catch (error) {
+    return { id: fallbackId, error: { message: safeErrorMessage(error, workspaceRoot) } };
+  }
+}
+async function writeResponse(output, response) {
+  if (!output.write(`${JSON.stringify(response)}
+`)) {
+    await once(output, "drain");
+  }
+}
+async function runWorker(options = {}) {
+  const workspaceRoot = options.cwd ?? process.cwd();
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const bash = createJustBash(workspaceRoot, { mounts: options.mounts });
+  const lines = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+  const close = () => lines.close();
+  if (options.signal?.aborted) {
+    close();
+  } else {
+    options.signal?.addEventListener("abort", close, { once: true });
+  }
+  try {
+    for await (const line of lines) {
+      await writeResponse(output, await handleWorkerLine(bash, line, workspaceRoot));
+    }
+  } finally {
+    options.signal?.removeEventListener("abort", close);
+    lines.close();
+  }
+}
+
+// src/utils/output.ts
+var encoder = new TextEncoder();
+function truncateText(input, maxBytes) {
+  if (maxBytes <= 0) {
+    return {
+      text: "\n[truncated: output limit is 0 bytes]",
+      truncated: input.length > 0
+    };
+  }
+  if (encoder.encode(input).byteLength <= maxBytes) {
+    return { text: input, truncated: false };
+  }
+  let bytes = 0;
+  let end = 0;
+  for (const char of input) {
+    const size = encoder.encode(char).byteLength;
+    if (bytes + size > maxBytes) {
+      break;
+    }
+    bytes += size;
+    end += char.length;
+  }
+  return {
+    text: `${input.slice(0, end)}
+[truncated: output exceeded ${maxBytes} bytes]`,
+    truncated: true
+  };
+}
+
+// src/cli-program.ts
+function addExecOptions(command, ndjsonDescription = "emit one JSON result record") {
+  return command.option("--cwd <path>", "working directory").option("--timeout <ms>", "command timeout in milliseconds").option("--max-output <bytes>", "maximum retained output").option("--ndjson", ndjsonDescription);
+}
+function collectOption(value, previous) {
+  return [...previous ?? [], value];
+}
+function addMountOption(command) {
+  return command.option(
+    "--mount <host-path:sandbox-path>",
+    "mount a host directory read-write (repeatable)",
+    collectOption
+  );
+}
+function addAgentOptions(command) {
+  return addMountOption(addExecOptions(command, "emit newline-delimited JSON event records")).option("--provider <provider>", "model provider", "openai").option("--model <model>", "model id").option(
+    "--executor <executor>",
+    "delegated executor: none, local, or daytona (local is unisolated; daytona requires DAYTONA_API_KEY)",
+    "none"
+  ).option("--max-steps <number>", "maximum model/tool steps").option("--no-color", "disable color output");
+}
+async function runAgent(promptParts, options) {
+  const prompt = promptParts.join(" ").trim();
+  if (!prompt) {
+    throw new CliError('A prompt is required. Example: ollie agent "summarize this repository"');
+  }
+  const config = await resolveRunConfig(options);
+  const renderer = createRenderer({ ndjson: config.ndjson, color: config.color });
+  const controller = new AbortController();
+  const onSigint = () => controller.abort();
+  process.once("SIGINT", onSigint);
+  try {
+    const exitCode = await runOneShot({
+      ...config,
+      prompt,
+      signal: controller.signal,
+      onEvent: (event) => renderer.render(event)
+    });
+    process.exitCode = exitCode;
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+}
+async function runExec(commandParts, options) {
+  const shellCommand = commandParts.join(" ").trim();
+  if (!shellCommand) {
+    throw new CliError('A command is required. Example: ollie "pwd && ls -la"');
+  }
+  const config = await resolveRunConfig(options);
+  const controller = new AbortController();
+  let signalExitCode;
+  const onSigint = () => {
+    signalExitCode = 130;
+    controller.abort();
+  };
+  const onSigterm = () => {
+    signalExitCode = 143;
+    controller.abort();
+  };
+  process.once("SIGINT", onSigint);
+  process.once("SIGTERM", onSigterm);
+  try {
+    const result = await runExecCommand(
+      config.cwd,
+      shellCommand,
+      {
+        timeoutMs: config.commandTimeoutMs,
+        env: process.env
+      },
+      controller.signal
+    );
+    const stdout = truncateText(result.stdout, config.maxOutputBytes);
+    const stderr = truncateText(result.stderr, config.maxOutputBytes);
+    if (config.ndjson) {
+      process.stdout.write(
+        `${JSON.stringify({
+          exitCode: result.exitCode,
+          stdout: stdout.text,
+          stderr: stderr.text,
+          durationMs: result.durationMs,
+          timedOut: result.timedOut,
+          truncated: stdout.truncated || stderr.truncated
+        })}
+`
+      );
+    } else {
+      if (stdout.text) {
+        process.stdout.write(stdout.text);
+      }
+      if (stderr.text) {
+        process.stderr.write(stderr.text);
+      }
+    }
+    process.exitCode = signalExitCode ?? (result.timedOut ? 124 : result.exitCode);
+  } catch (error) {
+    if (signalExitCode !== void 0) {
+      process.exitCode = signalExitCode;
+      return;
+    }
+    throw error;
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+    process.removeListener("SIGTERM", onSigterm);
+  }
+}
+async function runSandbox(options) {
+  const controller = new AbortController();
+  let signalExitCode;
+  const onSigint = () => {
+    signalExitCode = 130;
+    controller.abort();
+  };
+  const onSigterm = () => {
+    signalExitCode = 143;
+    controller.abort();
+  };
+  process.once("SIGINT", onSigint);
+  process.once("SIGTERM", onSigterm);
+  try {
+    await runWorker({
+      cwd: options.cwd,
+      mounts: parseSandboxMounts(options.mount),
+      signal: controller.signal
+    });
+    if (signalExitCode !== void 0) {
+      process.exitCode = signalExitCode;
+    }
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+    process.removeListener("SIGTERM", onSigterm);
+  }
+}
+function createRootProgram() {
+  const program = new Command();
+  program.name("ollie").description(`${packageName}: sandboxed command runner and optional model agent`).version(packageVersion).enablePositionalOptions().passThroughOptions().exitOverride();
+  addExecOptions(program.argument("[command...]", "command to execute in a fresh sandbox")).action(
+    async (commandParts, options) => {
+      await runExec(commandParts, options);
+    }
+  );
+  return program;
+}
+function createProgram() {
+  const program = createRootProgram();
+  const agent = addAgentOptions(
+    program.command("agent").description("run a one-shot model agent task").argument("[prompt...]", "task prompt").enablePositionalOptions().passThroughOptions()
+  );
+  agent.action(async (prompt, options) => {
+    await runAgent(prompt, options);
+  });
+  const sandbox = addMountOption(
+    program.command("sandbox").description("run the persistent sandbox NDJSON command interface").option("--cwd <path>", "working directory")
+  );
+  sandbox.action(async (options) => {
+    await runSandbox(options);
+  });
+  program.command("doctor").description("validate the local Ollie setup without making model calls").option("--cwd <path>", "working directory").option("--provider <provider>", "model provider", "openai").option("--model <model>", "model id").option("--json", "emit JSON report").action(async (options) => {
+    const config = await resolveRunConfig(options);
+    process.exitCode = await runDoctor(config);
+  });
+  return program;
+}
+var RESERVED_SUBCOMMANDS = /* @__PURE__ */ new Set(["agent", "sandbox", "doctor"]);
+var ROOT_OPTIONS_WITH_VALUES = /* @__PURE__ */ new Set(["--cwd", "--timeout", "--max-output"]);
+function rootBoundaryPrecedesCommand(args) {
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index] ?? "";
+    if (token === "--") {
+      return true;
+    }
+    if (RESERVED_SUBCOMMANDS.has(token)) {
+      return false;
+    }
+    if (ROOT_OPTIONS_WITH_VALUES.has(token)) {
+      index += 1;
+      continue;
+    }
+    if ([...ROOT_OPTIONS_WITH_VALUES].some((option) => token.startsWith(`${option}=`))) {
+      continue;
+    }
+    if (token === "--ndjson") {
+      continue;
+    }
+    return false;
+  }
+  return false;
+}
+async function main(argv = process.argv) {
+  const args = argv.slice(2);
+  const program = rootBoundaryPrecedesCommand(args) ? createRootProgram() : createProgram();
+  if (args.length === 0) {
+    program.outputHelp();
+    throw new CliError('A command is required. Example: ollie "pwd && ls -la"');
+  }
+  await program.parseAsync(argv);
+}
+
+// src/cli.ts
+main().catch((error) => {
+  if (error instanceof CommanderError) {
+    process.exitCode = error.exitCode;
+    return;
+  }
+  process.stderr.write(`error: ${getErrorMessage(error)}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map