alchemylab-opencode 1.0.1 → 1.0.4

package/dist/chunk-CMAI7CAJ.js

@@ -0,0 +1,2270 @@
+// Built by esbuild from opencode-server source
+import {
+  withStatics
+} from "./chunk-P44FI4UK.js";
+import {
+  __export,
+  __reExport
+} from "./chunk-7JG6KCBC.js";
+
+// packages/opencode/src/effect/run-service.ts
+import { Effect as Effect5, Layer as Layer4, ManagedRuntime } from "effect";
+
+// packages/opencode/src/bus/global.ts
+import { EventEmitter } from "events";
+var GlobalBus = new EventEmitter();
+
+// packages/opencode/src/effect/instance-registry.ts
+var disposers = /* @__PURE__ */ new Set();
+function registerDisposer(disposer) {
+  disposers.add(disposer);
+  return () => {
+    disposers.delete(disposer);
+  };
+}
+async function disposeInstance(directory) {
+  await Promise.allSettled([...disposers].map((disposer) => disposer(directory)));
+}
+
+// packages/opencode/src/util/filesystem.ts
+import { chmod, mkdir, readFile, stat as statFile, writeFile } from "fs/promises";
+import { createWriteStream, existsSync, statSync } from "fs";
+import { lookup } from "mime-types";
+import { realpathSync } from "fs";
+import { dirname, join, relative, resolve as pathResolve, win32 } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+
+// packages/opencode/src/util/glob.ts
+import { glob, globSync } from "glob";
+import { minimatch } from "minimatch";
+var Glob;
+((Glob2) => {
+  function toGlobOptions(options) {
+    return {
+      cwd: options.cwd,
+      absolute: options.absolute,
+      dot: options.dot,
+      follow: options.symlink ?? false,
+      nodir: options.include !== "all"
+    };
+  }
+  async function scan(pattern, options = {}) {
+    return glob(pattern, toGlobOptions(options));
+  }
+  Glob2.scan = scan;
+  function scanSync(pattern, options = {}) {
+    return globSync(pattern, toGlobOptions(options));
+  }
+  Glob2.scanSync = scanSync;
+  function match(pattern, filepath) {
+    return minimatch(filepath, pattern, { dot: true });
+  }
+  Glob2.match = match;
+})(Glob || (Glob = {}));
+
+// packages/opencode/src/util/filesystem.ts
+var Filesystem;
+((Filesystem2) => {
+  async function exists(p) {
+    return existsSync(p);
+  }
+  Filesystem2.exists = exists;
+  async function isDir(p) {
+    try {
+      return statSync(p).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  Filesystem2.isDir = isDir;
+  function stat(p) {
+    return statSync(p, { throwIfNoEntry: false }) ?? void 0;
+  }
+  Filesystem2.stat = stat;
+  async function statAsync(p) {
+    return statFile(p).catch((e) => {
+      if (isEnoent(e)) return void 0;
+      throw e;
+    });
+  }
+  Filesystem2.statAsync = statAsync;
+  async function size(p) {
+    const s = stat(p)?.size ?? 0;
+    return typeof s === "bigint" ? Number(s) : s;
+  }
+  Filesystem2.size = size;
+  async function readText(p) {
+    return readFile(p, "utf-8");
+  }
+  Filesystem2.readText = readText;
+  async function readJson(p) {
+    return JSON.parse(await readFile(p, "utf-8"));
+  }
+  Filesystem2.readJson = readJson;
+  async function readBytes(p) {
+    return readFile(p);
+  }
+  Filesystem2.readBytes = readBytes;
+  async function readArrayBuffer(p) {
+    const buf = await readFile(p);
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+  Filesystem2.readArrayBuffer = readArrayBuffer;
+  function isEnoent(e) {
+    return typeof e === "object" && e !== null && "code" in e && e.code === "ENOENT";
+  }
+  async function write(p, content, mode) {
+    try {
+      if (mode) {
+        await writeFile(p, content, { mode });
+      } else {
+        await writeFile(p, content);
+      }
+    } catch (e) {
+      if (isEnoent(e)) {
+        await mkdir(dirname(p), { recursive: true });
+        if (mode) {
+          await writeFile(p, content, { mode });
+        } else {
+          await writeFile(p, content);
+        }
+        return;
+      }
+      throw e;
+    }
+  }
+  Filesystem2.write = write;
+  async function writeJson(p, data2, mode) {
+    return write(p, JSON.stringify(data2, null, 2), mode);
+  }
+  Filesystem2.writeJson = writeJson;
+  async function writeStream(p, stream, mode) {
+    const dir = dirname(p);
+    if (!existsSync(dir)) {
+      await mkdir(dir, { recursive: true });
+    }
+    const nodeStream = stream instanceof ReadableStream ? Readable.fromWeb(stream) : stream;
+    const writeStream2 = createWriteStream(p);
+    await pipeline(nodeStream, writeStream2);
+    if (mode) {
+      await chmod(p, mode);
+    }
+  }
+  Filesystem2.writeStream = writeStream;
+  function mimeType(p) {
+    return lookup(p) || "application/octet-stream";
+  }
+  Filesystem2.mimeType = mimeType;
+  function normalizePath(p) {
+    if (process.platform !== "win32") return p;
+    const resolved = win32.normalize(win32.resolve(windowsPath(p)));
+    try {
+      return realpathSync.native(resolved);
+    } catch {
+      return resolved;
+    }
+  }
+  Filesystem2.normalizePath = normalizePath;
+  function normalizePathPattern(p) {
+    if (process.platform !== "win32") return p;
+    if (p === "*") return p;
+    const match = p.match(/^(.*)[\\/]\*$/);
+    if (!match) return normalizePath(p);
+    const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1];
+    return join(normalizePath(dir), "*");
+  }
+  Filesystem2.normalizePathPattern = normalizePathPattern;
+  function resolve(p) {
+    const resolved = pathResolve(windowsPath(p));
+    try {
+      return normalizePath(realpathSync(resolved));
+    } catch (e) {
+      if (isEnoent(e)) return normalizePath(resolved);
+      throw e;
+    }
+  }
+  Filesystem2.resolve = resolve;
+  function windowsPath(p) {
+    if (process.platform !== "win32") return p;
+    return p.replace(/^\/([a-zA-Z]):(?:[\\/]|$)/, (_, drive) => `${drive.toUpperCase()}:/`).replace(/^\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`).replace(/^\/cygdrive\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`).replace(/^\/mnt\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`);
+  }
+  Filesystem2.windowsPath = windowsPath;
+  function overlaps(a, b) {
+    const relA = relative(a, b);
+    const relB = relative(b, a);
+    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..");
+  }
+  Filesystem2.overlaps = overlaps;
+  function contains(parent, child) {
+    return !relative(parent, child).startsWith("..");
+  }
+  Filesystem2.contains = contains;
+  async function findUp(target, start, stop, options) {
+    const dirs = [start];
+    let current = start;
+    while (true) {
+      if (stop === current) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      dirs.push(parent);
+      current = parent;
+    }
+    const targets = Array.isArray(target) ? target : [target];
+    const result = [];
+    for (const dir of options?.rootFirst ? dirs.toReversed() : dirs) {
+      for (const item of targets) {
+        const search = join(dir, item);
+        if (await exists(search)) result.push(search);
+      }
+    }
+    return result;
+  }
+  Filesystem2.findUp = findUp;
+  async function* up(options) {
+    const { targets, start, stop } = options;
+    let current = start;
+    while (true) {
+      for (const target of targets) {
+        const search = join(current, target);
+        if (await exists(search)) yield search;
+      }
+      if (stop === current) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+  }
+  Filesystem2.up = up;
+  async function globUp(pattern, start, stop) {
+    let current = start;
+    const result = [];
+    while (true) {
+      try {
+        const matches = await Glob.scan(pattern, {
+          cwd: current,
+          absolute: true,
+          include: "file",
+          dot: true
+        });
+        result.push(...matches);
+      } catch {
+      }
+      if (stop === current) break;
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+    return result;
+  }
+  Filesystem2.globUp = globUp;
+})(Filesystem || (Filesystem = {}));
+
+// packages/opencode/src/util/iife.ts
+function iife(fn) {
+  return fn();
+}
+
+// packages/opencode/src/util/log.ts
+import path2 from "path";
+import fs2 from "fs/promises";
+import { createWriteStream as createWriteStream2 } from "fs";
+
+// packages/opencode/src/global/index.ts
+import fs from "fs/promises";
+import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir";
+import path from "path";
+import os from "os";
+var app = "opencode";
+var customDataDir = process.env["OPENCODE_DATA_DIR"];
+var data = customDataDir || path.join(xdgData, app);
+var cache = path.join(xdgCache, app);
+var config = customDataDir ? path.join(customDataDir, "config") : path.join(xdgConfig, app);
+var state = customDataDir ? path.join(customDataDir, "state") : path.join(xdgState, app);
+var Global;
+((Global2) => {
+  Global2.Path = {
+    // Allow override via OPENCODE_TEST_HOME for test isolation
+    get home() {
+      return process.env.OPENCODE_TEST_HOME || os.homedir();
+    },
+    data,
+    bin: path.join(cache, "bin"),
+    log: path.join(data, "log"),
+    cache,
+    config,
+    state
+  };
+})(Global || (Global = {}));
+await Promise.all([
+  fs.mkdir(Global.Path.data, { recursive: true }),
+  fs.mkdir(Global.Path.config, { recursive: true }),
+  fs.mkdir(Global.Path.state, { recursive: true }),
+  fs.mkdir(Global.Path.log, { recursive: true }),
+  fs.mkdir(Global.Path.bin, { recursive: true })
+]);
+var CACHE_VERSION = "21";
+var version = await Filesystem.readText(path.join(Global.Path.cache, "version")).catch(() => "0");
+if (version !== CACHE_VERSION) {
+  try {
+    const contents = await fs.readdir(Global.Path.cache);
+    await Promise.all(
+      contents.map(
+        (item) => fs.rm(path.join(Global.Path.cache, item), {
+          recursive: true,
+          force: true
+        })
+      )
+    );
+  } catch (e) {
+  }
+  await Filesystem.write(path.join(Global.Path.cache, "version"), CACHE_VERSION);
+}
+
+// packages/opencode/src/util/log.ts
+import z from "zod";
+var Log;
+((Log2) => {
+  Log2.Level = z.enum(["DEBUG", "INFO", "WARN", "ERROR"]).meta({ ref: "LogLevel", description: "Log level" });
+  const levelPriority = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3
+  };
+  let level = "INFO";
+  function shouldLog(input) {
+    return levelPriority[input] >= levelPriority[level];
+  }
+  const loggers = /* @__PURE__ */ new Map();
+  Log2.Default = create({ service: "default" });
+  let logpath = "";
+  function file() {
+    return logpath;
+  }
+  Log2.file = file;
+  let write = (msg) => {
+    process.stderr.write(msg);
+    return msg.length;
+  };
+  async function init2(options) {
+    if (options.level) level = options.level;
+    cleanup(Global.Path.log);
+    if (options.print) return;
+    logpath = path2.join(
+      Global.Path.log,
+      options.dev ? "dev.log" : (/* @__PURE__ */ new Date()).toISOString().split(".")[0].replace(/:/g, "") + ".log"
+    );
+    await fs2.truncate(logpath).catch(() => {
+    });
+    const stream = createWriteStream2(logpath, { flags: "a" });
+    write = async (msg) => {
+      return new Promise((resolve, reject) => {
+        stream.write(msg, (err) => {
+          if (err) reject(err);
+          else resolve(msg.length);
+        });
+      });
+    };
+  }
+  Log2.init = init2;
+  async function cleanup(dir) {
+    const files = await Glob.scan("????-??-??T??????.log", {
+      cwd: dir,
+      absolute: true,
+      include: "file"
+    });
+    if (files.length <= 5) return;
+    const filesToDelete = files.slice(0, -10);
+    await Promise.all(filesToDelete.map((file2) => fs2.unlink(file2).catch(() => {
+    })));
+  }
+  function formatError(error, depth = 0) {
+    const result = error.message;
+    return error.cause instanceof Error && depth < 10 ? result + " Caused by: " + formatError(error.cause, depth + 1) : result;
+  }
+  let last = Date.now();
+  function create(tags) {
+    tags = tags || {};
+    const service = tags["service"];
+    if (service && typeof service === "string") {
+      const cached = loggers.get(service);
+      if (cached) {
+        return cached;
+      }
+    }
+    function build(message, extra) {
+      const prefix = Object.entries({
+        ...tags,
+        ...extra
+      }).filter(([_, value]) => value !== void 0 && value !== null).map(([key, value]) => {
+        const prefix2 = `${key}=`;
+        if (value instanceof Error) return prefix2 + formatError(value);
+        if (typeof value === "object") return prefix2 + JSON.stringify(value);
+        return prefix2 + value;
+      }).join(" ");
+      const next = /* @__PURE__ */ new Date();
+      const diff = next.getTime() - last;
+      last = next.getTime();
+      return [next.toISOString().split(".")[0], "+" + diff + "ms", prefix, message].filter(Boolean).join(" ") + "\n";
+    }
+    const result = {
+      debug(message, extra) {
+        if (shouldLog("DEBUG")) {
+          write("DEBUG " + build(message, extra));
+        }
+      },
+      info(message, extra) {
+        if (shouldLog("INFO")) {
+          write("INFO  " + build(message, extra));
+        }
+      },
+      error(message, extra) {
+        if (shouldLog("ERROR")) {
+          write("ERROR " + build(message, extra));
+        }
+      },
+      warn(message, extra) {
+        if (shouldLog("WARN")) {
+          write("WARN  " + build(message, extra));
+        }
+      },
+      tag(key, value) {
+        if (tags) tags[key] = value;
+        return result;
+      },
+      clone() {
+        return Log2.create({ ...tags });
+      },
+      time(message, extra) {
+        const now = Date.now();
+        result.info(message, { status: "started", ...extra });
+        function stop() {
+          result.info(message, {
+            status: "completed",
+            duration: Date.now() - now,
+            ...extra
+          });
+        }
+        return {
+          stop,
+          [Symbol.dispose]() {
+            stop();
+          }
+        };
+      }
+    };
+    if (service && typeof service === "string") {
+      loggers.set(service, result);
+    }
+    return result;
+  }
+  Log2.create = create;
+})(Log || (Log = {}));
+
+// packages/opencode/src/util/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var Context;
+((Context2) => {
+  class NotFound extends Error {
+    constructor(name) {
+      super(`No context found for ${name}`);
+      this.name = name;
+    }
+    name;
+  }
+  Context2.NotFound = NotFound;
+  function create(name) {
+    const storage = new AsyncLocalStorage();
+    return {
+      use() {
+        const result = storage.getStore();
+        if (!result) {
+          throw new NotFound(name);
+        }
+        return result;
+      },
+      provide(value, fn) {
+        return storage.run(value, fn);
+      }
+    };
+  }
+  Context2.create = create;
+})(Context || (Context = {}));
+
+// packages/opencode/src/project/project.ts
+import z6 from "zod";
+
+// packages/opencode/src/storage/db.ts
+var db_exports = {};
+__export(db_exports, {
+  Database: () => Database,
+  NotFoundError: () => NotFoundError
+});
+__reExport(db_exports, drizzle_orm_star);
+import { migrate } from "drizzle-orm/node-sqlite/migrator";
+import * as drizzle_orm_star from "drizzle-orm";
+
+// packages/opencode/src/util/lazy.ts
+function lazy(fn) {
+  let value;
+  let loaded = false;
+  const result = () => {
+    if (loaded) return value;
+    try {
+      value = fn();
+      loaded = true;
+      return value;
+    } catch (e) {
+      throw e;
+    }
+  };
+  result.reset = () => {
+    loaded = false;
+    value = void 0;
+  };
+  return result;
+}
+
+// packages/util/src/error.ts
+import z2 from "zod";
+var NamedError = class _NamedError extends Error {
+  static create(name, data2) {
+    const schema = z2.object({
+      name: z2.literal(name),
+      data: data2
+    }).meta({
+      ref: name
+    });
+    const result = class extends _NamedError {
+      constructor(data3, options) {
+        super(name, options);
+        this.data = data3;
+        this.name = name;
+      }
+      data;
+      static Schema = schema;
+      name = name;
+      static isInstance(input) {
+        return typeof input === "object" && "name" in input && input.name === name;
+      }
+      schema() {
+        return schema;
+      }
+      toObject() {
+        return {
+          name,
+          data: this.data
+        };
+      }
+    };
+    Object.defineProperty(result, "name", { value: name });
+    return result;
+  }
+  static Unknown = _NamedError.create(
+    "UnknownError",
+    z2.object({
+      message: z2.string()
+    })
+  );
+};
+
+// packages/opencode/src/storage/db.ts
+import z3 from "zod";
+import path3 from "path";
+import { readFileSync, readdirSync, existsSync as existsSync2 } from "fs";
+
+// packages/opencode/src/flag/flag.ts
+import { Config } from "effect";
+function truthy(key) {
+  const value = process.env[key]?.toLowerCase();
+  return value === "true" || value === "1";
+}
+function falsy(key) {
+  const value = process.env[key]?.toLowerCase();
+  return value === "false" || value === "0";
+}
+var Flag;
+((Flag2) => {
+  Flag2.OPENCODE_AUTO_SHARE = truthy("OPENCODE_AUTO_SHARE");
+  Flag2.OPENCODE_AUTO_HEAP_SNAPSHOT = truthy("OPENCODE_AUTO_HEAP_SNAPSHOT");
+  Flag2.OPENCODE_GIT_BASH_PATH = process.env["OPENCODE_GIT_BASH_PATH"];
+  Flag2.OPENCODE_CONFIG = process.env["OPENCODE_CONFIG"];
+  Flag2.OPENCODE_CONFIG_CONTENT = process.env["OPENCODE_CONFIG_CONTENT"];
+  Flag2.OPENCODE_DISABLE_AUTOUPDATE = truthy("OPENCODE_DISABLE_AUTOUPDATE");
+  Flag2.OPENCODE_ALWAYS_NOTIFY_UPDATE = truthy("OPENCODE_ALWAYS_NOTIFY_UPDATE");
+  Flag2.OPENCODE_DISABLE_PRUNE = truthy("OPENCODE_DISABLE_PRUNE");
+  Flag2.OPENCODE_DISABLE_TERMINAL_TITLE = truthy("OPENCODE_DISABLE_TERMINAL_TITLE");
+  Flag2.OPENCODE_SHOW_TTFD = truthy("OPENCODE_SHOW_TTFD");
+  Flag2.OPENCODE_PERMISSION = process.env["OPENCODE_PERMISSION"];
+  Flag2.OPENCODE_DISABLE_DEFAULT_PLUGINS = truthy("OPENCODE_DISABLE_DEFAULT_PLUGINS");
+  Flag2.OPENCODE_DISABLE_LSP_DOWNLOAD = truthy("OPENCODE_DISABLE_LSP_DOWNLOAD");
+  Flag2.OPENCODE_ENABLE_EXPERIMENTAL_MODELS = truthy("OPENCODE_ENABLE_EXPERIMENTAL_MODELS");
+  Flag2.OPENCODE_DISABLE_AUTOCOMPACT = truthy("OPENCODE_DISABLE_AUTOCOMPACT");
+  Flag2.OPENCODE_DISABLE_MODELS_FETCH = truthy("OPENCODE_DISABLE_MODELS_FETCH");
+  Flag2.OPENCODE_DISABLE_MOUSE = truthy("OPENCODE_DISABLE_MOUSE");
+  Flag2.OPENCODE_DISABLE_CLAUDE_CODE = truthy("OPENCODE_DISABLE_CLAUDE_CODE");
+  Flag2.OPENCODE_DISABLE_CLAUDE_CODE_PROMPT = Flag2.OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_PROMPT");
+  Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS = Flag2.OPENCODE_DISABLE_CLAUDE_CODE || truthy("OPENCODE_DISABLE_CLAUDE_CODE_SKILLS");
+  Flag2.OPENCODE_DISABLE_EXTERNAL_SKILLS = Flag2.OPENCODE_DISABLE_CLAUDE_CODE_SKILLS || truthy("OPENCODE_DISABLE_EXTERNAL_SKILLS");
+  Flag2.OPENCODE_FAKE_VCS = process.env["OPENCODE_FAKE_VCS"];
+  Flag2.OPENCODE_SERVER_PASSWORD = process.env["OPENCODE_SERVER_PASSWORD"];
+  Flag2.OPENCODE_SERVER_USERNAME = process.env["OPENCODE_SERVER_USERNAME"];
+  Flag2.OPENCODE_ENABLE_QUESTION_TOOL = truthy("OPENCODE_ENABLE_QUESTION_TOOL");
+  Flag2.OPENCODE_EXPERIMENTAL = truthy("OPENCODE_EXPERIMENTAL");
+  Flag2.OPENCODE_EXPERIMENTAL_FILEWATCHER = Config.boolean("OPENCODE_EXPERIMENTAL_FILEWATCHER").pipe(
+    Config.withDefault(false)
+  );
+  Flag2.OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER = Config.boolean(
+    "OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER"
+  ).pipe(Config.withDefault(false));
+  Flag2.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_ICON_DISCOVERY");
+  const copy = process.env["OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT"];
+  Flag2.OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT = copy === void 0 ? process.platform === "win32" : truthy("OPENCODE_EXPERIMENTAL_DISABLE_COPY_ON_SELECT");
+  Flag2.OPENCODE_ENABLE_EXA = truthy("OPENCODE_ENABLE_EXA") || Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_EXA");
+  Flag2.OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS = number("OPENCODE_EXPERIMENTAL_BASH_DEFAULT_TIMEOUT_MS");
+  Flag2.OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX = number("OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX");
+  Flag2.OPENCODE_EXPERIMENTAL_OXFMT = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_OXFMT");
+  Flag2.OPENCODE_EXPERIMENTAL_LSP_TY = truthy("OPENCODE_EXPERIMENTAL_LSP_TY");
+  Flag2.OPENCODE_EXPERIMENTAL_LSP_TOOL = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_LSP_TOOL");
+  Flag2.OPENCODE_DISABLE_FILETIME_CHECK = Config.boolean("OPENCODE_DISABLE_FILETIME_CHECK").pipe(
+    Config.withDefault(false)
+  );
+  Flag2.OPENCODE_EXPERIMENTAL_PLAN_MODE = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_PLAN_MODE");
+  Flag2.OPENCODE_EXPERIMENTAL_WORKSPACES = Flag2.OPENCODE_EXPERIMENTAL || truthy("OPENCODE_EXPERIMENTAL_WORKSPACES");
+  Flag2.OPENCODE_EXPERIMENTAL_MARKDOWN = !falsy("OPENCODE_EXPERIMENTAL_MARKDOWN");
+  Flag2.OPENCODE_MODELS_URL = process.env["OPENCODE_MODELS_URL"];
+  Flag2.OPENCODE_MODELS_PATH = process.env["OPENCODE_MODELS_PATH"];
+  Flag2.OPENCODE_DISABLE_EMBEDDED_WEB_UI = truthy("OPENCODE_DISABLE_EMBEDDED_WEB_UI");
+  Flag2.OPENCODE_DB = process.env["OPENCODE_DB"];
+  Flag2.OPENCODE_DISABLE_CHANNEL_DB = truthy("OPENCODE_DISABLE_CHANNEL_DB");
+  Flag2.OPENCODE_SKIP_MIGRATIONS = truthy("OPENCODE_SKIP_MIGRATIONS");
+  Flag2.OPENCODE_STRICT_CONFIG_DEPS = truthy("OPENCODE_STRICT_CONFIG_DEPS");
+  function number(key) {
+    const value = process.env[key];
+    if (!value) return void 0;
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
+  }
+})(Flag || (Flag = {}));
+Object.defineProperty(Flag, "OPENCODE_DISABLE_PROJECT_CONFIG", {
+  get() {
+    return truthy("OPENCODE_DISABLE_PROJECT_CONFIG");
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_TUI_CONFIG", {
+  get() {
+    return process.env["OPENCODE_TUI_CONFIG"];
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_CONFIG_DIR", {
+  get() {
+    return process.env["OPENCODE_CONFIG_DIR"];
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_PURE", {
+  get() {
+    return truthy("OPENCODE_PURE");
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_PLUGIN_META_FILE", {
+  get() {
+    return process.env["OPENCODE_PLUGIN_META_FILE"];
+  },
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Flag, "OPENCODE_CLIENT", {
+  get() {
+    return process.env["OPENCODE_CLIENT"] ?? "cli";
+  },
+  enumerable: true,
+  configurable: false
+});
+
+// packages/opencode/src/installation/meta.ts
+var VERSION = typeof OPENCODE_VERSION === "string" ? OPENCODE_VERSION : "local";
+var CHANNEL = typeof OPENCODE_CHANNEL === "string" ? OPENCODE_CHANNEL : "local";
+
+// packages/opencode/src/effect/instance-state.ts
+import { Effect, Fiber, ScopedCache, ServiceMap as ServiceMap2 } from "effect";
+
+// packages/opencode/src/effect/instance-ref.ts
+import { ServiceMap } from "effect";
+var InstanceRef = ServiceMap.Reference("~opencode/InstanceRef", {
+  defaultValue: () => void 0
+});
+
+// packages/opencode/src/effect/instance-state.ts
+var TypeId = "~opencode/InstanceState";
+var InstanceState;
+((InstanceState2) => {
+  InstanceState2.bind = (fn) => {
+    try {
+      return Instance.bind(fn);
+    } catch (err) {
+      if (!(err instanceof Context.NotFound)) throw err;
+    }
+    const fiber = Fiber.getCurrent();
+    const ctx = fiber ? ServiceMap2.getReferenceUnsafe(fiber.services, InstanceRef) : void 0;
+    if (!ctx) return fn;
+    return ((...args) => Instance.restore(ctx, () => fn(...args)));
+  };
+  InstanceState2.context = Effect.gen(function* () {
+    return (yield* InstanceRef) ?? Instance.current;
+  });
+  InstanceState2.directory = Effect.map(InstanceState2.context, (ctx) => ctx.directory);
+  InstanceState2.make = (init2) => Effect.gen(function* () {
+    const cache3 = yield* ScopedCache.make({
+      capacity: Number.POSITIVE_INFINITY,
+      lookup: () => Effect.gen(function* () {
+        return yield* init2(yield* InstanceState2.context);
+      })
+    });
+    const off = registerDisposer((directory2) => Effect.runPromise(ScopedCache.invalidate(cache3, directory2)));
+    yield* Effect.addFinalizer(() => Effect.sync(off));
+    return {
+      [TypeId]: TypeId,
+      cache: cache3
+    };
+  });
+  InstanceState2.get = (self) => Effect.gen(function* () {
+    return yield* ScopedCache.get(self.cache, yield* InstanceState2.directory);
+  });
+  InstanceState2.use = (self, select) => Effect.map((0, InstanceState2.get)(self), select);
+  InstanceState2.useEffect = (self, select) => Effect.flatMap((0, InstanceState2.get)(self), select);
+  InstanceState2.has = (self) => Effect.gen(function* () {
+    return yield* ScopedCache.has(self.cache, yield* InstanceState2.directory);
+  });
+  InstanceState2.invalidate = (self) => Effect.gen(function* () {
+    return yield* ScopedCache.invalidate(self.cache, yield* InstanceState2.directory);
+  });
+  InstanceState2.withALS = (fn) => Effect.map(InstanceState2.context, (ctx) => Instance.restore(ctx, fn));
+})(InstanceState || (InstanceState = {}));
+
+// packages/opencode/src/storage/db.node.ts
+import { DatabaseSync } from "node:sqlite";
+import { drizzle } from "drizzle-orm/node-sqlite";
+function init(path5) {
+  const sqlite = new DatabaseSync(path5);
+  const db = drizzle({ client: sqlite });
+  return db;
+}
+
+// packages/opencode/src/storage/db.ts
+var NotFoundError = NamedError.create(
+  "NotFoundError",
+  z3.object({
+    message: z3.string()
+  })
+);
+var log = Log.create({ service: "db" });
+var Database;
+((Database2) => {
+  function getChannelPath() {
+    if (["latest", "beta"].includes(CHANNEL) || Flag.OPENCODE_DISABLE_CHANNEL_DB)
+      return path3.join(Global.Path.data, "opencode.db");
+    const safe = CHANNEL.replace(/[^a-zA-Z0-9._-]/g, "-");
+    return path3.join(Global.Path.data, `opencode-${safe}.db`);
+  }
+  Database2.getChannelPath = getChannelPath;
+  Database2.Path = iife(() => {
+    if (Flag.OPENCODE_DB) {
+      if (Flag.OPENCODE_DB === ":memory:" || path3.isAbsolute(Flag.OPENCODE_DB)) return Flag.OPENCODE_DB;
+      return path3.join(Global.Path.data, Flag.OPENCODE_DB);
+    }
+    return getChannelPath();
+  });
+  function time(tag) {
+    const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(tag);
+    if (!match) return 0;
+    return Date.UTC(
+      Number(match[1]),
+      Number(match[2]) - 1,
+      Number(match[3]),
+      Number(match[4]),
+      Number(match[5]),
+      Number(match[6])
+    );
+  }
+  function migrations(dir) {
+    const dirs = readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    const sql = dirs.map((name) => {
+      const file = path3.join(dir, name, "migration.sql");
+      if (!existsSync2(file)) return;
+      return {
+        sql: readFileSync(file, "utf-8"),
+        timestamp: time(name),
+        name
+      };
+    }).filter(Boolean);
+    return sql.sort((a, b) => a.timestamp - b.timestamp);
+  }
+  Database2.Client = lazy(() => {
+    log.info("opening database", { path: Database2.Path });
+    const db = init(Database2.Path);
+    db.run("PRAGMA journal_mode = WAL");
+    db.run("PRAGMA synchronous = NORMAL");
+    db.run("PRAGMA busy_timeout = 5000");
+    db.run("PRAGMA cache_size = -64000");
+    db.run("PRAGMA foreign_keys = ON");
+    db.run("PRAGMA wal_checkpoint(PASSIVE)");
+    const migrationsDir = path3.join(import.meta.dirname, "../packages/opencode/migration");
+    if (typeof OPENCODE_MIGRATIONS !== "undefined") {
+      const entries = OPENCODE_MIGRATIONS;
+      if (entries.length > 0) {
+        log.info("applying migrations", { count: entries.length, mode: "bundled" });
+        if (Flag.OPENCODE_SKIP_MIGRATIONS) {
+          for (const item of entries) item.sql = "select 1;";
+        }
+        migrate(db, entries);
+      }
+    } else {
+      const entries = migrations(migrationsDir);
+      log.info("applying migrations", { count: entries.length, mode: "dev" });
+      if (!Flag.OPENCODE_SKIP_MIGRATIONS && entries.length > 0) {
+        migrate(db, { migrationsFolder: migrationsDir });
+      }
+    }
+    return db;
+  });
+  function close() {
+    (0, Database2.Client)().$client.close();
+    Database2.Client.reset();
+  }
+  Database2.close = close;
+  const ctx = Context.create("database");
+  function use(callback2) {
+    try {
+      return callback2(ctx.use().tx);
+    } catch (err) {
+      if (err instanceof Context.NotFound) {
+        const effects = [];
+        const result = ctx.provide({ effects, tx: (0, Database2.Client)() }, () => callback2((0, Database2.Client)()));
+        for (const effect3 of effects) effect3();
+        return result;
+      }
+      throw err;
+    }
+  }
+  Database2.use = use;
+  function effect2(fn) {
+    const bound = InstanceState.bind(fn);
+    try {
+      ctx.use().effects.push(bound);
+    } catch {
+      bound();
+    }
+  }
+  Database2.effect = effect2;
+  function transaction(callback2, options) {
+    try {
+      return callback2(ctx.use().tx);
+    } catch (err) {
+      if (err instanceof Context.NotFound) {
+        const effects = [];
+        const txCallback = InstanceState.bind((tx) => ctx.provide({ tx, effects }, () => callback2(tx)));
+        const result = (0, Database2.Client)().transaction(txCallback, { behavior: options?.behavior });
+        for (const effect3 of effects) effect3();
+        return result;
+      }
+      throw err;
+    }
+  }
+  Database2.transaction = transaction;
+})(Database || (Database = {}));
+
+// packages/opencode/src/project/project.sql.ts
+import { sqliteTable, text, integer as integer2 } from "drizzle-orm/sqlite-core";
+
+// packages/opencode/src/storage/schema.sql.ts
+import { integer } from "drizzle-orm/sqlite-core";
+var Timestamps = {
+  time_created: integer().notNull().$default(() => Date.now()),
+  time_updated: integer().notNull().$onUpdate(() => Date.now())
+};
+
+// packages/opencode/src/project/project.sql.ts
+var ProjectTable = sqliteTable("project", {
+  id: text().$type().primaryKey(),
+  worktree: text().notNull(),
+  vcs: text(),
+  name: text(),
+  icon_url: text(),
+  icon_color: text(),
+  ...Timestamps,
+  time_initialized: integer2(),
+  sandboxes: text({ mode: "json" }).notNull().$type(),
+  commands: text({ mode: "json" }).$type()
+});
+
+// packages/opencode/src/session/session.sql.ts
+import { sqliteTable as sqliteTable2, text as text2, integer as integer3, index, primaryKey } from "drizzle-orm/sqlite-core";
+var SessionTable = sqliteTable2(
+  "session",
+  {
+    id: text2().$type().primaryKey(),
+    project_id: text2().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+    workspace_id: text2().$type(),
+    parent_id: text2().$type(),
+    slug: text2().notNull(),
+    directory: text2().notNull(),
+    title: text2().notNull(),
+    version: text2().notNull(),
+    share_url: text2(),
+    summary_additions: integer3(),
+    summary_deletions: integer3(),
+    summary_files: integer3(),
+    summary_diffs: text2({ mode: "json" }).$type(),
+    revert: text2({ mode: "json" }).$type(),
+    permission: text2({ mode: "json" }).$type(),
+    ...Timestamps,
+    time_compacting: integer3(),
+    time_archived: integer3()
+  },
+  (table) => [
+    index("session_project_idx").on(table.project_id),
+    index("session_workspace_idx").on(table.workspace_id),
+    index("session_parent_idx").on(table.parent_id)
+  ]
+);
+var MessageTable = sqliteTable2(
+  "message",
+  {
+    id: text2().$type().primaryKey(),
+    session_id: text2().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
+    ...Timestamps,
+    data: text2({ mode: "json" }).notNull().$type()
+  },
+  (table) => [index("message_session_time_created_id_idx").on(table.session_id, table.time_created, table.id)]
+);
+var PartTable = sqliteTable2(
+  "part",
+  {
+    id: text2().$type().primaryKey(),
+    message_id: text2().$type().notNull().references(() => MessageTable.id, { onDelete: "cascade" }),
+    session_id: text2().$type().notNull(),
+    ...Timestamps,
+    data: text2({ mode: "json" }).notNull().$type()
+  },
+  (table) => [
+    index("part_message_id_id_idx").on(table.message_id, table.id),
+    index("part_session_idx").on(table.session_id)
+  ]
+);
+var TodoTable = sqliteTable2(
+  "todo",
+  {
+    session_id: text2().$type().notNull().references(() => SessionTable.id, { onDelete: "cascade" }),
+    content: text2().notNull(),
+    status: text2().notNull(),
+    priority: text2().notNull(),
+    position: integer3().notNull(),
+    ...Timestamps
+  },
+  (table) => [
+    primaryKey({ columns: [table.session_id, table.position] }),
+    index("todo_session_idx").on(table.session_id)
+  ]
+);
+var PermissionTable = sqliteTable2("permission", {
+  project_id: text2().primaryKey().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  ...Timestamps,
+  data: text2({ mode: "json" }).notNull().$type()
+});
+
+// packages/opencode/src/bus/bus-event.ts
+import z4 from "zod";
+var BusEvent;
+((BusEvent2) => {
+  const registry = /* @__PURE__ */ new Map();
+  function define(type, properties) {
+    const result = {
+      type,
+      properties
+    };
+    registry.set(type, result);
+    return result;
+  }
+  BusEvent2.define = define;
+  function payloads() {
+    return z4.discriminatedUnion(
+      "type",
+      registry.entries().map(([type, def]) => {
+        return z4.object({
+          type: z4.literal(type),
+          properties: def.properties
+        }).meta({
+          ref: "Event." + def.type
+        });
+      }).toArray()
+    ).meta({
+      ref: "Event"
+    });
+  }
+  BusEvent2.payloads = payloads;
+})(BusEvent || (BusEvent = {}));
+
+// packages/opencode/src/util/which.ts
+import whichPkg from "which";
+import path4 from "path";
+function which(cmd, env) {
+  const base = env?.PATH ?? env?.Path ?? process.env.PATH ?? process.env.Path ?? "";
+  const full = base ? base + path4.delimiter + Global.Path.bin : Global.Path.bin;
+  const result = whichPkg.sync(cmd, {
+    nothrow: true,
+    path: full,
+    pathExt: env?.PATHEXT ?? env?.PathExt ?? process.env.PATHEXT ?? process.env.PathExt
+  });
+  return typeof result === "string" ? result : null;
+}
+
+// packages/opencode/src/project/schema.ts
+import { Schema } from "effect";
+import z5 from "zod";
+var projectIdSchema = Schema.String.pipe(Schema.brand("ProjectID"));
+var ProjectID = projectIdSchema.pipe(
+  withStatics((schema) => ({
+    global: schema.makeUnsafe("global"),
+    make: (id) => schema.makeUnsafe(id),
+    zod: z5.string().pipe(z5.custom())
+  }))
+);
+
+// packages/opencode/src/project/project.ts
+import { Effect as Effect4, Layer as Layer3, Path as Path3, Scope as Scope2, ServiceMap as ServiceMap4, Stream as Stream2 } from "effect";
+import { ChildProcess as ChildProcess2, ChildProcessSpawner as ChildProcessSpawner2 } from "effect/unstable/process";
+import { NodePath as NodePath2 } from "@effect/platform-node";
+
+// packages/opencode/src/filesystem/index.ts
+import { NodeFileSystem } from "@effect/platform-node";
+import { dirname as dirname2, join as join2, relative as relative2, resolve as pathResolve2 } from "path";
+import { realpathSync as realpathSync2 } from "fs";
+import * as NFS from "fs/promises";
+import { lookup as lookup2 } from "mime-types";
+import { Effect as Effect2, FileSystem, Layer, Schema as Schema2, ServiceMap as ServiceMap3 } from "effect";
+var AppFileSystem;
+((AppFileSystem2) => {
+  class FileSystemError extends Schema2.TaggedErrorClass()("FileSystemError", {
+    method: Schema2.String,
+    cause: Schema2.optional(Schema2.Defect)
+  }) {
+  }
+  AppFileSystem2.FileSystemError = FileSystemError;
+  class Service extends ServiceMap3.Service()("@opencode/FileSystem") {
+  }
+  AppFileSystem2.Service = Service;
+  AppFileSystem2.layer = Layer.effect(
+    Service,
+    Effect2.gen(function* () {
+      const fs3 = yield* FileSystem.FileSystem;
+      const existsSafe = Effect2.fn("FileSystem.existsSafe")(function* (path5) {
+        return yield* fs3.exists(path5).pipe(Effect2.orElseSucceed(() => false));
+      });
+      const isDir = Effect2.fn("FileSystem.isDir")(function* (path5) {
+        const info = yield* fs3.stat(path5).pipe(Effect2.catch(() => Effect2.void));
+        return info?.type === "Directory";
+      });
+      const isFile = Effect2.fn("FileSystem.isFile")(function* (path5) {
+        const info = yield* fs3.stat(path5).pipe(Effect2.catch(() => Effect2.void));
+        return info?.type === "File";
+      });
+      const readDirectoryEntries = Effect2.fn("FileSystem.readDirectoryEntries")(function* (dirPath) {
+        return yield* Effect2.tryPromise({
+          try: async () => {
+            const entries = await NFS.readdir(dirPath, { withFileTypes: true });
+            return entries.map(
+              (e) => ({
+                name: e.name,
+                type: e.isDirectory() ? "directory" : e.isSymbolicLink() ? "symlink" : e.isFile() ? "file" : "other"
+              })
+            );
+          },
+          catch: (cause) => new FileSystemError({ method: "readDirectoryEntries", cause })
+        });
+      });
+      const readJson = Effect2.fn("FileSystem.readJson")(function* (path5) {
+        const text3 = yield* fs3.readFileString(path5);
+        return JSON.parse(text3);
+      });
+      const writeJson = Effect2.fn("FileSystem.writeJson")(function* (path5, data2, mode) {
+        const content = JSON.stringify(data2, null, 2);
+        yield* fs3.writeFileString(path5, content);
+        if (mode) yield* fs3.chmod(path5, mode);
+      });
+      const ensureDir = Effect2.fn("FileSystem.ensureDir")(function* (path5) {
+        yield* fs3.makeDirectory(path5, { recursive: true });
+      });
+      const writeWithDirs = Effect2.fn("FileSystem.writeWithDirs")(function* (path5, content, mode) {
+        const write = typeof content === "string" ? fs3.writeFileString(path5, content) : fs3.writeFile(path5, content);
+        yield* write.pipe(
+          Effect2.catchIf(
+            (e) => e.reason._tag === "NotFound",
+            () => Effect2.gen(function* () {
+              yield* fs3.makeDirectory(dirname2(path5), { recursive: true });
+              yield* write;
+            })
+          )
+        );
+        if (mode) yield* fs3.chmod(path5, mode);
+      });
+      const glob2 = Effect2.fn("FileSystem.glob")(function* (pattern, options) {
+        return yield* Effect2.tryPromise({
+          try: () => Glob.scan(pattern, options),
+          catch: (cause) => new FileSystemError({ method: "glob", cause })
+        });
+      });
+      const findUp = Effect2.fn("FileSystem.findUp")(function* (target, start, stop) {
+        const result = [];
+        let current = start;
+        while (true) {
+          const search = join2(current, target);
+          if (yield* fs3.exists(search)) result.push(search);
+          if (stop === current) break;
+          const parent = dirname2(current);
+          if (parent === current) break;
+          current = parent;
+        }
+        return result;
+      });
+      const up = Effect2.fn("FileSystem.up")(function* (options) {
+        const result = [];
+        let current = options.start;
+        while (true) {
+          for (const target of options.targets) {
+            const search = join2(current, target);
+            if (yield* fs3.exists(search)) result.push(search);
+          }
+          if (options.stop === current) break;
+          const parent = dirname2(current);
+          if (parent === current) break;
+          current = parent;
+        }
+        return result;
+      });
+      const globUp = Effect2.fn("FileSystem.globUp")(function* (pattern, start, stop) {
+        const result = [];
+        let current = start;
+        while (true) {
+          const matches = yield* glob2(pattern, { cwd: current, absolute: true, include: "file", dot: true }).pipe(
+            Effect2.catch(() => Effect2.succeed([]))
+          );
+          result.push(...matches);
+          if (stop === current) break;
+          const parent = dirname2(current);
+          if (parent === current) break;
+          current = parent;
+        }
+        return result;
+      });
+      return Service.of({
+        ...fs3,
+        existsSafe,
+        isDir,
+        isFile,
+        readDirectoryEntries,
+        readJson,
+        writeJson,
+        ensureDir,
+        writeWithDirs,
+        findUp,
+        up,
+        globUp,
+        glob: glob2,
+        globMatch: Glob.match
+      });
+    })
+  );
+  AppFileSystem2.defaultLayer = AppFileSystem2.layer.pipe(Layer.provide(NodeFileSystem.layer));
+  function mimeType(p) {
+    return lookup2(p) || "application/octet-stream";
+  }
+  AppFileSystem2.mimeType = mimeType;
+  function normalizePath(p) {
+    if (process.platform !== "win32") return p;
+    const resolved = pathResolve2(windowsPath(p));
+    try {
+      return realpathSync2.native(resolved);
+    } catch {
+      return resolved;
+    }
+  }
+  AppFileSystem2.normalizePath = normalizePath;
+  function normalizePathPattern(p) {
+    if (process.platform !== "win32") return p;
+    if (p === "*") return p;
+    const match = p.match(/^(.*)[\\/]\*$/);
+    if (!match) return normalizePath(p);
+    const dir = /^[A-Za-z]:$/.test(match[1]) ? match[1] + "\\" : match[1];
+    return join2(normalizePath(dir), "*");
+  }
+  AppFileSystem2.normalizePathPattern = normalizePathPattern;
+  function resolve(p) {
+    const resolved = pathResolve2(windowsPath(p));
+    try {
+      return normalizePath(realpathSync2(resolved));
+    } catch (e) {
+      if (e?.code === "ENOENT") return normalizePath(resolved);
+      throw e;
+    }
+  }
+  AppFileSystem2.resolve = resolve;
+  function windowsPath(p) {
+    if (process.platform !== "win32") return p;
+    return p.replace(/^\/([a-zA-Z]):(?:[\\/]|$)/, (_, drive) => `${drive.toUpperCase()}:/`).replace(/^\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`).replace(/^\/cygdrive\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`).replace(/^\/mnt\/([a-zA-Z])(?:\/|$)/, (_, drive) => `${drive.toUpperCase()}:/`);
+  }
+  AppFileSystem2.windowsPath = windowsPath;
+  function overlaps(a, b) {
+    const relA = relative2(a, b);
+    const relB = relative2(b, a);
+    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..");
+  }
+  AppFileSystem2.overlaps = overlaps;
+  function contains(parent, child) {
+    return !relative2(parent, child).startsWith("..");
+  }
+  AppFileSystem2.contains = contains;
+})(AppFileSystem || (AppFileSystem = {}));
+
+// packages/opencode/src/effect/cross-spawn-spawner.ts
+import { NodeFileSystem as NodeFileSystem2, NodeSink, NodeStream } from "@effect/platform-node";
+import * as NodePath from "@effect/platform-node/NodePath";
+import * as Deferred from "effect/Deferred";
+import * as Effect3 from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as FileSystem2 from "effect/FileSystem";
+import * as Layer2 from "effect/Layer";
+import * as Path from "effect/Path";
+import * as PlatformError from "effect/PlatformError";
+import * as Predicate from "effect/Predicate";
+import * as Sink from "effect/Sink";
+import * as Stream from "effect/Stream";
+import * as ChildProcess from "effect/unstable/process/ChildProcess";
+import {
+  ChildProcessSpawner,
+  ExitCode,
+  make as makeSpawner,
+  makeHandle,
+  ProcessId
+} from "effect/unstable/process/ChildProcessSpawner";
+import * as NodeChildProcess from "node:child_process";
+import { PassThrough } from "node:stream";
+import launch from "cross-spawn";
+var toError = (err) => err instanceof globalThis.Error ? err : new globalThis.Error(String(err));
+var toTag = (err) => {
+  switch (err.code) {
+    case "ENOENT":
+      return "NotFound";
+    case "EACCES":
+      return "PermissionDenied";
+    case "EEXIST":
+      return "AlreadyExists";
+    case "EISDIR":
+      return "BadResource";
+    case "ENOTDIR":
+      return "BadResource";
+    case "EBUSY":
+      return "Busy";
+    case "ELOOP":
+      return "BadResource";
+    default:
+      return "Unknown";
+  }
+};
+var flatten = (command) => {
+  const commands = [];
+  const opts = [];
+  const walk = (cmd) => {
+    switch (cmd._tag) {
+      case "StandardCommand":
+        commands.push(cmd);
+        return;
+      case "PipedCommand":
+        walk(cmd.left);
+        opts.push(cmd.options);
+        walk(cmd.right);
+        return;
+    }
+  };
+  walk(command);
+  if (commands.length === 0) throw new Error("flatten produced empty commands array");
+  const [head, ...tail] = commands;
+  return {
+    commands: [head, ...tail],
+    opts
+  };
+};
+var toPlatformError = (method, err, command) => {
+  const cmd = flatten(command).commands.map((x) => `${x.command} ${x.args.join(" ")}`).join(" | ");
+  return PlatformError.systemError({
+    _tag: toTag(err),
+    module: "ChildProcess",
+    method,
+    pathOrDescriptor: cmd,
+    syscall: err.syscall,
+    cause: err
+  });
+};
+var make2 = Effect3.gen(function* () {
+  const fs3 = yield* FileSystem2.FileSystem;
+  const path5 = yield* Path.Path;
+  const cwd = Effect3.fnUntraced(function* (opts) {
+    if (Predicate.isUndefined(opts.cwd)) return void 0;
+    yield* fs3.access(opts.cwd);
+    return path5.resolve(opts.cwd);
+  });
+  const env = (opts) => opts.extendEnv ? { ...globalThis.process.env, ...opts.env } : opts.env;
+  const input = (x) => Stream.isStream(x) ? "pipe" : x;
+  const output = (x) => Sink.isSink(x) ? "pipe" : x;
+  const stdin = (opts) => {
+    const cfg = { stream: "pipe", encoding: "utf-8", endOnDone: true };
+    if (Predicate.isUndefined(opts.stdin)) return cfg;
+    if (typeof opts.stdin === "string") return { ...cfg, stream: opts.stdin };
+    if (Stream.isStream(opts.stdin)) return { ...cfg, stream: opts.stdin };
+    return {
+      stream: opts.stdin.stream,
+      encoding: opts.stdin.encoding ?? cfg.encoding,
+      endOnDone: opts.stdin.endOnDone ?? cfg.endOnDone
+    };
+  };
+  const stdio = (opts, key) => {
+    const cfg = opts[key];
+    if (Predicate.isUndefined(cfg)) return { stream: "pipe" };
+    if (typeof cfg === "string") return { stream: cfg };
+    if (Sink.isSink(cfg)) return { stream: cfg };
+    return { stream: cfg.stream };
+  };
+  const fds = (opts) => {
+    if (Predicate.isUndefined(opts.additionalFds)) return [];
+    return Object.entries(opts.additionalFds).flatMap(([name, config2]) => {
+      const fd = ChildProcess.parseFdName(name);
+      return Predicate.isUndefined(fd) ? [] : [{ fd, config: config2 }];
+    }).toSorted((a, b) => a.fd - b.fd);
+  };
+  const stdios = (sin, sout, serr, extra) => {
+    const pipe = (x) => process.platform === "win32" && x === "pipe" ? "overlapped" : x;
+    const arr = [
+      pipe(input(sin.stream)),
+      pipe(output(sout.stream)),
+      pipe(output(serr.stream))
+    ];
+    if (extra.length === 0) return arr;
+    const max = extra.reduce((acc, x) => Math.max(acc, x.fd), 2);
+    for (let i = 3; i <= max; i++) arr[i] = "ignore";
+    for (const x of extra) arr[x.fd] = pipe("pipe");
+    return arr;
+  };
+  const setupFds = Effect3.fnUntraced(function* (command, proc, extra) {
+    if (extra.length === 0) {
+      return {
+        getInputFd: () => Sink.drain,
+        getOutputFd: () => Stream.empty
+      };
+    }
+    const ins = /* @__PURE__ */ new Map();
+    const outs = /* @__PURE__ */ new Map();
+    for (const x of extra) {
+      const node = proc.stdio[x.fd];
+      switch (x.config.type) {
+        case "input": {
+          let sink = Sink.drain;
+          if (node && "write" in node) {
+            sink = NodeSink.fromWritable({
+              evaluate: () => node,
+              onError: (err) => toPlatformError(`fromWritable(fd${x.fd})`, toError(err), command),
+              endOnDone: true
+            });
+          }
+          if (x.config.stream) yield* Effect3.forkScoped(Stream.run(x.config.stream, sink));
+          ins.set(x.fd, sink);
+          break;
+        }
+        case "output": {
+          let stream = Stream.empty;
+          if (node && "read" in node) {
+            const tap = new PassThrough();
+            node.on("error", (err) => tap.destroy(toError(err)));
+            node.pipe(tap);
+            stream = NodeStream.fromReadable({
+              evaluate: () => tap,
+              onError: (err) => toPlatformError(`fromReadable(fd${x.fd})`, toError(err), command)
+            });
+          }
+          if (x.config.sink) stream = Stream.transduce(stream, x.config.sink);
+          outs.set(x.fd, stream);
+          break;
+        }
+      }
+    }
+    return {
+      getInputFd: (fd) => ins.get(fd) ?? Sink.drain,
+      getOutputFd: (fd) => outs.get(fd) ?? Stream.empty
+    };
+  });
+  const setupStdin = (command, proc, cfg) => Effect3.suspend(() => {
+    let sink = Sink.drain;
+    if (Predicate.isNotNull(proc.stdin)) {
+      sink = NodeSink.fromWritable({
+        evaluate: () => proc.stdin,
+        onError: (err) => toPlatformError("fromWritable(stdin)", toError(err), command),
+        endOnDone: cfg.endOnDone,
+        encoding: cfg.encoding
+      });
+    }
+    if (Stream.isStream(cfg.stream)) return Effect3.as(Effect3.forkScoped(Stream.run(cfg.stream, sink)), sink);
+    return Effect3.succeed(sink);
+  });
+  const setupOutput = (command, proc, out, err) => {
+    let stdout = proc.stdout ? NodeStream.fromReadable({
+      evaluate: () => proc.stdout,
+      onError: (cause) => toPlatformError("fromReadable(stdout)", toError(cause), command)
+    }) : Stream.empty;
+    let stderr = proc.stderr ? NodeStream.fromReadable({
+      evaluate: () => proc.stderr,
+      onError: (cause) => toPlatformError("fromReadable(stderr)", toError(cause), command)
+    }) : Stream.empty;
+    if (Sink.isSink(out.stream)) stdout = Stream.transduce(stdout, out.stream);
+    if (Sink.isSink(err.stream)) stderr = Stream.transduce(stderr, err.stream);
+    return { stdout, stderr, all: Stream.merge(stdout, stderr) };
+  };
+  const spawn = (command, opts) => Effect3.callback((resume) => {
+    const signal = Deferred.makeUnsafe();
+    const proc = launch(command.command, command.args, opts);
+    let end = false;
+    let exit;
+    proc.on("error", (err) => {
+      resume(Effect3.fail(toPlatformError("spawn", err, command)));
+    });
+    proc.on("exit", (...args) => {
+      exit = args;
+    });
+    proc.on("close", (...args) => {
+      if (end) return;
+      end = true;
+      Deferred.doneUnsafe(signal, Exit.succeed(exit ?? args));
+    });
+    proc.on("spawn", () => {
+      resume(Effect3.succeed([proc, signal]));
+    });
+    return Effect3.sync(() => {
+      proc.kill("SIGTERM");
+    });
+  });
+  const killGroup = (command, proc, signal) => {
+    if (globalThis.process.platform === "win32") {
+      return Effect3.callback((resume) => {
+        NodeChildProcess.exec(`taskkill /pid ${proc.pid} /T /F`, { windowsHide: true }, (err) => {
+          if (err) return resume(Effect3.fail(toPlatformError("kill", toError(err), command)));
+          resume(Effect3.void);
+        });
+      });
+    }
+    return Effect3.try({
+      try: () => {
+        globalThis.process.kill(-proc.pid, signal);
+      },
+      catch: (err) => toPlatformError("kill", toError(err), command)
+    });
+  };
+  const killOne = (command, proc, signal) => Effect3.suspend(() => {
+    if (proc.kill(signal)) return Effect3.void;
+    return Effect3.fail(toPlatformError("kill", new Error("Failed to kill child process"), command));
+  });
+  const timeout = (proc, command, opts) => (f) => {
+    const signal = opts?.killSignal ?? "SIGTERM";
+    if (Predicate.isUndefined(opts?.forceKillAfter)) return f(command, proc, signal);
+    return Effect3.timeoutOrElse(f(command, proc, signal), {
+      duration: opts.forceKillAfter,
+      orElse: () => f(command, proc, "SIGKILL")
+    });
+  };
+  const source = (handle, from) => {
+    const opt = from ?? "stdout";
+    switch (opt) {
+      case "stdout":
+        return handle.stdout;
+      case "stderr":
+        return handle.stderr;
+      case "all":
+        return handle.all;
+      default: {
+        const fd = ChildProcess.parseFdName(opt);
+        return Predicate.isNotUndefined(fd) ? handle.getOutputFd(fd) : handle.stdout;
+      }
+    }
+  };
+  const spawnCommand = Effect3.fnUntraced(
+    function* (command) {
+      switch (command._tag) {
+        case "StandardCommand": {
+          const sin = stdin(command.options);
+          const sout = stdio(command.options, "stdout");
+          const serr = stdio(command.options, "stderr");
+          const extra = fds(command.options);
+          const dir = yield* cwd(command.options);
+          const [proc, signal] = yield* Effect3.acquireRelease(
+            spawn(command, {
+              cwd: dir,
+              env: env(command.options),
+              stdio: stdios(sin, sout, serr, extra),
+              detached: command.options.detached ?? process.platform !== "win32",
+              shell: command.options.shell,
+              windowsHide: process.platform === "win32"
+            }),
+            Effect3.fnUntraced(function* ([proc2, signal2]) {
+              const done = yield* Deferred.isDone(signal2);
+              const kill = timeout(proc2, command, command.options);
+              if (done) {
+                const [code] = yield* Deferred.await(signal2);
+                if (process.platform === "win32") return yield* Effect3.void;
+                if (code !== 0 && Predicate.isNotNull(code)) return yield* Effect3.ignore(kill(killGroup));
+                return yield* Effect3.void;
+              }
+              const send = (s) => Effect3.catch(killGroup(command, proc2, s), () => killOne(command, proc2, s));
+              const sig = command.options.killSignal ?? "SIGTERM";
+              const attempt = send(sig).pipe(Effect3.andThen(Deferred.await(signal2)), Effect3.asVoid);
+              const escalated = command.options.forceKillAfter ? Effect3.timeoutOrElse(attempt, {
+                duration: command.options.forceKillAfter,
+                orElse: () => send("SIGKILL").pipe(Effect3.andThen(Deferred.await(signal2)), Effect3.asVoid)
+              }) : attempt;
+              return yield* Effect3.ignore(escalated);
+            })
+          );
+          const fd = yield* setupFds(command, proc, extra);
+          const out = setupOutput(command, proc, sout, serr);
+          return makeHandle({
+            pid: ProcessId(proc.pid),
+            stdin: yield* setupStdin(command, proc, sin),
+            stdout: out.stdout,
+            stderr: out.stderr,
+            all: out.all,
+            getInputFd: fd.getInputFd,
+            getOutputFd: fd.getOutputFd,
+            isRunning: Effect3.map(Deferred.isDone(signal), (done) => !done),
+            exitCode: Effect3.flatMap(Deferred.await(signal), ([code, signal2]) => {
+              if (Predicate.isNotNull(code)) return Effect3.succeed(ExitCode(code));
+              return Effect3.fail(
+                toPlatformError(
+                  "exitCode",
+                  new Error(`Process interrupted due to receipt of signal: '${signal2}'`),
+                  command
+                )
+              );
+            }),
+            kill: (opts) => {
+              const sig = opts?.killSignal ?? "SIGTERM";
+              const send = (s) => Effect3.catch(killGroup(command, proc, s), () => killOne(command, proc, s));
+              const attempt = send(sig).pipe(Effect3.andThen(Deferred.await(signal)), Effect3.asVoid);
+              if (!opts?.forceKillAfter) return attempt;
+              return Effect3.timeoutOrElse(attempt, {
+                duration: opts.forceKillAfter,
+                orElse: () => send("SIGKILL").pipe(Effect3.andThen(Deferred.await(signal)), Effect3.asVoid)
+              });
+            }
+          });
+        }
+        case "PipedCommand": {
+          const flat = flatten(command);
+          const [head, ...tail] = flat.commands;
+          let handle = spawnCommand(head);
+          for (let i = 0; i < tail.length; i++) {
+            const next = tail[i];
+            const opts = flat.opts[i] ?? {};
+            const sin = stdin(next.options);
+            const stream = Stream.unwrap(Effect3.map(handle, (x) => source(x, opts.from)));
+            const to = opts.to ?? "stdin";
+            if (to === "stdin") {
+              handle = spawnCommand(
+                ChildProcess.make(next.command, next.args, {
+                  ...next.options,
+                  stdin: { ...sin, stream }
+                })
+              );
+              continue;
+            }
+            const fd = ChildProcess.parseFdName(to);
+            if (Predicate.isUndefined(fd)) {
+              handle = spawnCommand(
+                ChildProcess.make(next.command, next.args, {
+                  ...next.options,
+                  stdin: { ...sin, stream }
+                })
+              );
+              continue;
+            }
+            handle = spawnCommand(
+              ChildProcess.make(next.command, next.args, {
+                ...next.options,
+                additionalFds: {
+                  ...next.options.additionalFds,
+                  [ChildProcess.fdName(fd)]: { type: "input", stream }
+                }
+              })
+            );
+          }
+          return yield* handle;
+        }
+      }
+    }
+  );
+  return makeSpawner(spawnCommand);
+});
+var layer2 = Layer2.effect(
+  ChildProcessSpawner,
+  make2
+);
+var defaultLayer = layer2.pipe(Layer2.provide(NodeFileSystem2.layer), Layer2.provide(NodePath.layer));
+var rt = lazy(async () => {
+  const { makeRuntime: makeRuntime2 } = await import("./run-service-23VXHTA6.js");
+  return makeRuntime2(ChildProcessSpawner, defaultLayer);
+});
+var runPromiseExit = async (...args) => (await rt()).runPromiseExit(...args);
+
+// packages/opencode/src/project/project.ts
+var Project;
+((Project2) => {
+  const log2 = Log.create({ service: "project" });
+  Project2.Info = z6.object({
+    id: ProjectID.zod,
+    worktree: z6.string(),
+    vcs: z6.literal("git").optional(),
+    name: z6.string().optional(),
+    icon: z6.object({
+      url: z6.string().optional(),
+      override: z6.string().optional(),
+      color: z6.string().optional()
+    }).optional(),
+    commands: z6.object({
+      start: z6.string().optional().describe("Startup script to run when creating a new workspace (worktree)")
+    }).optional(),
+    time: z6.object({
+      created: z6.number(),
+      updated: z6.number(),
+      initialized: z6.number().optional()
+    }),
+    sandboxes: z6.array(z6.string())
+  }).meta({
+    ref: "Project"
+  });
+  Project2.Event = {
+    Updated: BusEvent.define("project.updated", Project2.Info)
+  };
+  function fromRow(row) {
+    const icon = row.icon_url || row.icon_color ? { url: row.icon_url ?? void 0, color: row.icon_color ?? void 0 } : void 0;
+    return {
+      id: row.id,
+      worktree: row.worktree,
+      vcs: row.vcs ? Project2.Info.shape.vcs.parse(row.vcs) : void 0,
+      name: row.name ?? void 0,
+      icon,
+      time: {
+        created: row.time_created,
+        updated: row.time_updated,
+        initialized: row.time_initialized ?? void 0
+      },
+      sandboxes: row.sandboxes,
+      commands: row.commands ?? void 0
+    };
+  }
+  Project2.fromRow = fromRow;
+  Project2.UpdateInput = z6.object({
+    projectID: ProjectID.zod,
+    name: z6.string().optional(),
+    icon: Project2.Info.shape.icon.optional(),
+    commands: Project2.Info.shape.commands.optional()
+  });
+  class Service extends ServiceMap4.Service()("@opencode/Project") {
+  }
+  Project2.Service = Service;
+  Project2.layer = Layer3.effect(
+    Service,
+    Effect4.gen(function* () {
+      const fs3 = yield* AppFileSystem.Service;
+      const pathSvc = yield* Path3.Path;
+      const spawner = yield* ChildProcessSpawner2.ChildProcessSpawner;
+      const git = Effect4.fnUntraced(
+        function* (args, opts) {
+          const handle = yield* spawner.spawn(
+            ChildProcess2.make("git", args, { cwd: opts?.cwd, extendEnv: true, stdin: "ignore" })
+          );
+          const [text3, stderr] = yield* Effect4.all(
+            [Stream2.mkString(Stream2.decodeText(handle.stdout)), Stream2.mkString(Stream2.decodeText(handle.stderr))],
+            { concurrency: 2 }
+          );
+          const code = yield* handle.exitCode;
+          return { code, text: text3, stderr };
+        },
+        Effect4.scoped,
+        Effect4.catch(() => Effect4.succeed({ code: 1, text: "", stderr: "" }))
+      );
+      const db = (fn) => Effect4.sync(() => Database.use(fn));
+      const emitUpdated = (data2) => Effect4.sync(
+        () => GlobalBus.emit("event", {
+          payload: { type: Project2.Event.Updated.type, properties: data2 }
+        })
+      );
+      const fakeVcs = Project2.Info.shape.vcs.parse(Flag.OPENCODE_FAKE_VCS);
+      const resolveGitPath = (cwd, name) => {
+        if (!name) return cwd;
+        name = name.replace(/[\r\n]+$/, "");
+        if (!name) return cwd;
+        name = AppFileSystem.windowsPath(name);
+        if (pathSvc.isAbsolute(name)) return pathSvc.normalize(name);
+        return pathSvc.resolve(cwd, name);
+      };
+      const scope = yield* Scope2.Scope;
+      const readCachedProjectId = Effect4.fnUntraced(function* (dir) {
+        return yield* fs3.readFileString(pathSvc.join(dir, "opencode")).pipe(
+          Effect4.map((x) => x.trim()),
+          Effect4.map(ProjectID.make),
+          Effect4.catch(() => Effect4.succeed(void 0))
+        );
+      });
+      const fromDirectory2 = Effect4.fn("Project.fromDirectory")(function* (directory) {
+        log2.info("fromDirectory", { directory });
+        const data2 = yield* Effect4.gen(function* () {
+          const dotgitMatches = yield* fs3.up({ targets: [".git"], start: directory }).pipe(Effect4.orDie);
+          const dotgit = dotgitMatches[0];
+          if (!dotgit) {
+            return {
+              id: ProjectID.global,
+              worktree: "/",
+              sandbox: "/",
+              vcs: fakeVcs
+            };
+          }
+          let sandbox = pathSvc.dirname(dotgit);
+          const gitBinary = yield* Effect4.sync(() => which("git"));
+          let id = yield* readCachedProjectId(dotgit);
+          if (!gitBinary) {
+            return {
+              id: id ?? ProjectID.global,
+              worktree: sandbox,
+              sandbox,
+              vcs: fakeVcs
+            };
+          }
+          const commonDir = yield* git(["rev-parse", "--git-common-dir"], { cwd: sandbox });
+          if (commonDir.code !== 0) {
+            return {
+              id: id ?? ProjectID.global,
+              worktree: sandbox,
+              sandbox,
+              vcs: fakeVcs
+            };
+          }
+          const worktree = (() => {
+            const common = resolveGitPath(sandbox, commonDir.text.trim());
+            return common === sandbox ? sandbox : pathSvc.dirname(common);
+          })();
+          if (id == null) {
+            id = yield* readCachedProjectId(pathSvc.join(worktree, ".git"));
+          }
+          if (!id) {
+            const revList = yield* git(["rev-list", "--max-parents=0", "HEAD"], { cwd: sandbox });
+            const roots = revList.text.split("\n").filter(Boolean).map((x) => x.trim()).toSorted();
+            id = roots[0] ? ProjectID.make(roots[0]) : void 0;
+            if (id) {
+              yield* fs3.writeFileString(pathSvc.join(worktree, ".git", "opencode"), id).pipe(Effect4.ignore);
+            }
+          }
+          if (!id) {
+            return { id: ProjectID.global, worktree: sandbox, sandbox, vcs: "git" };
+          }
+          const topLevel = yield* git(["rev-parse", "--show-toplevel"], { cwd: sandbox });
+          if (topLevel.code !== 0) {
+            return {
+              id,
+              worktree: sandbox,
+              sandbox,
+              vcs: fakeVcs
+            };
+          }
+          sandbox = resolveGitPath(sandbox, topLevel.text.trim());
+          return { id, sandbox, worktree, vcs: "git" };
+        });
+        const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, data2.id)).get());
+        const existing = row ? fromRow(row) : {
+          id: data2.id,
+          worktree: data2.worktree,
+          vcs: data2.vcs,
+          sandboxes: [],
+          time: { created: Date.now(), updated: Date.now() }
+        };
+        if (Flag.OPENCODE_EXPERIMENTAL_ICON_DISCOVERY)
+          yield* discover2(existing).pipe(Effect4.ignore, Effect4.forkIn(scope));
+        const result = {
+          ...existing,
+          worktree: data2.worktree,
+          vcs: data2.vcs,
+          time: { ...existing.time, updated: Date.now() }
+        };
+        if (data2.sandbox !== result.worktree && !result.sandboxes.includes(data2.sandbox))
+          result.sandboxes.push(data2.sandbox);
+        result.sandboxes = yield* Effect4.forEach(
+          result.sandboxes,
+          (s) => fs3.exists(s).pipe(
+            Effect4.orDie,
+            Effect4.map((exists) => exists ? s : void 0)
+          ),
+          { concurrency: "unbounded" }
+        ).pipe(Effect4.map((arr) => arr.filter((x) => x !== void 0)));
+        yield* db(
+          (d) => d.insert(ProjectTable).values({
+            id: result.id,
+            worktree: result.worktree,
+            vcs: result.vcs ?? null,
+            name: result.name,
+            icon_url: result.icon?.url,
+            icon_color: result.icon?.color,
+            time_created: result.time.created,
+            time_updated: result.time.updated,
+            time_initialized: result.time.initialized,
+            sandboxes: result.sandboxes,
+            commands: result.commands
+          }).onConflictDoUpdate({
+            target: ProjectTable.id,
+            set: {
+              worktree: result.worktree,
+              vcs: result.vcs ?? null,
+              name: result.name,
+              icon_url: result.icon?.url,
+              icon_color: result.icon?.color,
+              time_updated: result.time.updated,
+              time_initialized: result.time.initialized,
+              sandboxes: result.sandboxes,
+              commands: result.commands
+            }
+          }).run()
+        );
+        if (data2.id !== ProjectID.global) {
+          yield* db(
+            (d) => d.update(SessionTable).set({ project_id: data2.id }).where((0, db_exports.and)((0, db_exports.eq)(SessionTable.project_id, ProjectID.global), (0, db_exports.eq)(SessionTable.directory, data2.worktree))).run()
+          );
+        }
+        yield* emitUpdated(result);
+        return { project: result, sandbox: data2.sandbox };
+      });
+      const discover2 = Effect4.fn("Project.discover")(function* (input) {
+        if (input.vcs !== "git") return;
+        if (input.icon?.override) return;
+        if (input.icon?.url) return;
+        const matches = yield* fs3.glob("**/favicon.{ico,png,svg,jpg,jpeg,webp}", {
+          cwd: input.worktree,
+          absolute: true,
+          include: "file"
+        }).pipe(Effect4.orDie);
+        const shortest = matches.sort((a, b) => a.length - b.length)[0];
+        if (!shortest) return;
+        const buffer = yield* fs3.readFile(shortest).pipe(Effect4.orDie);
+        const base64 = Buffer.from(buffer).toString("base64");
+        const mime = AppFileSystem.mimeType(shortest);
+        const url = `data:${mime};base64,${base64}`;
+        yield* update2({ projectID: input.id, icon: { url } });
+      });
+      const list2 = Effect4.fn("Project.list")(function* () {
+        return yield* db((d) => d.select().from(ProjectTable).all().map(fromRow));
+      });
+      const get2 = Effect4.fn("Project.get")(function* (id) {
+        const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, id)).get());
+        return row ? fromRow(row) : void 0;
+      });
+      const update2 = Effect4.fn("Project.update")(function* (input) {
+        const result = yield* db(
+          (d) => d.update(ProjectTable).set({
+            name: input.name,
+            icon_url: input.icon?.url,
+            icon_color: input.icon?.color,
+            commands: input.commands,
+            time_updated: Date.now()
+          }).where((0, db_exports.eq)(ProjectTable.id, input.projectID)).returning().get()
+        );
+        if (!result) throw new Error(`Project not found: ${input.projectID}`);
+        const data2 = fromRow(result);
+        yield* emitUpdated(data2);
+        return data2;
+      });
+      const initGit2 = Effect4.fn("Project.initGit")(function* (input) {
+        if (input.project.vcs === "git") return input.project;
+        if (!(yield* Effect4.sync(() => which("git")))) throw new Error("Git is not installed");
+        const result = yield* git(["init", "--quiet"], { cwd: input.directory });
+        if (result.code !== 0) {
+          throw new Error(result.stderr.trim() || result.text.trim() || "Failed to initialize git repository");
+        }
+        const { project } = yield* fromDirectory2(input.directory);
+        return project;
+      });
+      const setInitialized2 = Effect4.fn("Project.setInitialized")(function* (id) {
+        yield* db(
+          (d) => d.update(ProjectTable).set({ time_initialized: Date.now() }).where((0, db_exports.eq)(ProjectTable.id, id)).run()
+        );
+      });
+      const sandboxes2 = Effect4.fn("Project.sandboxes")(function* (id) {
+        const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, id)).get());
+        if (!row) return [];
+        const data2 = fromRow(row);
+        return yield* Effect4.forEach(
+          data2.sandboxes,
+          (dir) => fs3.isDir(dir).pipe(
+            Effect4.orDie,
+            Effect4.map((ok) => ok ? dir : void 0)
+          ),
+          { concurrency: "unbounded" }
+        ).pipe(Effect4.map((arr) => arr.filter((x) => x !== void 0)));
+      });
+      const addSandbox2 = Effect4.fn("Project.addSandbox")(function* (id, directory) {
+        const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, id)).get());
+        if (!row) throw new Error(`Project not found: ${id}`);
+        const sboxes = [...row.sandboxes];
+        if (!sboxes.includes(directory)) sboxes.push(directory);
+        const result = yield* db(
+          (d) => d.update(ProjectTable).set({ sandboxes: sboxes, time_updated: Date.now() }).where((0, db_exports.eq)(ProjectTable.id, id)).returning().get()
+        );
+        if (!result) throw new Error(`Project not found: ${id}`);
+        yield* emitUpdated(fromRow(result));
+      });
+      const removeSandbox2 = Effect4.fn("Project.removeSandbox")(function* (id, directory) {
+        const row = yield* db((d) => d.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, id)).get());
+        if (!row) throw new Error(`Project not found: ${id}`);
+        const sboxes = row.sandboxes.filter((s) => s !== directory);
+        const result = yield* db(
+          (d) => d.update(ProjectTable).set({ sandboxes: sboxes, time_updated: Date.now() }).where((0, db_exports.eq)(ProjectTable.id, id)).returning().get()
+        );
+        if (!result) throw new Error(`Project not found: ${id}`);
+        yield* emitUpdated(fromRow(result));
+      });
+      return Service.of({
+        fromDirectory: fromDirectory2,
+        discover: discover2,
+        list: list2,
+        get: get2,
+        update: update2,
+        initGit: initGit2,
+        setInitialized: setInitialized2,
+        sandboxes: sandboxes2,
+        addSandbox: addSandbox2,
+        removeSandbox: removeSandbox2
+      });
+    })
+  );
+  Project2.defaultLayer = Project2.layer.pipe(
+    Layer3.provide(defaultLayer),
+    Layer3.provide(AppFileSystem.defaultLayer),
+    Layer3.provide(NodePath2.layer)
+  );
+  const { runPromise } = makeRuntime(Service, Project2.defaultLayer);
+  function fromDirectory(directory) {
+    return runPromise((svc) => svc.fromDirectory(directory));
+  }
+  Project2.fromDirectory = fromDirectory;
+  function discover(input) {
+    return runPromise((svc) => svc.discover(input));
+  }
+  Project2.discover = discover;
+  function list() {
+    return Database.use(
+      (db) => db.select().from(ProjectTable).all().map((row) => fromRow(row))
+    );
+  }
+  Project2.list = list;
+  function get(id) {
+    const row = Database.use((db) => db.select().from(ProjectTable).where((0, db_exports.eq)(ProjectTable.id, id)).get());
+    if (!row) return void 0;
+    return fromRow(row);
+  }
+  Project2.get = get;
+  function setInitialized(id) {
+    Database.use(
+      (db) => db.update(ProjectTable).set({ time_initialized: Date.now() }).where((0, db_exports.eq)(ProjectTable.id, id)).run()
+    );
+  }
+  Project2.setInitialized = setInitialized;
+  function initGit(input) {
+    return runPromise((svc) => svc.initGit(input));
+  }
+  Project2.initGit = initGit;
+  function update(input) {
+    return runPromise((svc) => svc.update(input));
+  }
+  Project2.update = update;
+  function sandboxes(id) {
+    return runPromise((svc) => svc.sandboxes(id));
+  }
+  Project2.sandboxes = sandboxes;
+  function addSandbox(id, directory) {
+    return runPromise((svc) => svc.addSandbox(id, directory));
+  }
+  Project2.addSandbox = addSandbox;
+  function removeSandbox(id, directory) {
+    return runPromise((svc) => svc.removeSandbox(id, directory));
+  }
+  Project2.removeSandbox = removeSandbox;
+})(Project || (Project = {}));
+
+// packages/opencode/src/project/state.ts
+var State;
+((State2) => {
+  const log2 = Log.create({ service: "state" });
+  const recordsByKey = /* @__PURE__ */ new Map();
+  function create(root, init2, dispose2) {
+    return () => {
+      const key = root();
+      let entries = recordsByKey.get(key);
+      if (!entries) {
+        entries = /* @__PURE__ */ new Map();
+        recordsByKey.set(key, entries);
+      }
+      const exists = entries.get(init2);
+      if (exists) return exists.state;
+      const state2 = init2();
+      entries.set(init2, {
+        state: state2,
+        dispose: dispose2
+      });
+      return state2;
+    };
+  }
+  State2.create = create;
+  async function dispose(key) {
+    const entries = recordsByKey.get(key);
+    if (!entries) return;
+    log2.info("waiting for state disposal to complete", { key });
+    let disposalFinished = false;
+    setTimeout(() => {
+      if (!disposalFinished) {
+        log2.warn(
+          "state disposal is taking an unusually long time - if it does not complete in a reasonable time, please report this as a bug",
+          { key }
+        );
+      }
+    }, 1e4).unref();
+    const tasks = [];
+    for (const [init2, entry] of entries) {
+      if (!entry.dispose) continue;
+      const label = typeof init2 === "function" ? init2.name : String(init2);
+      const task = Promise.resolve(entry.state).then((state2) => entry.dispose(state2)).catch((error) => {
+        log2.error("Error while disposing state:", { error, key, init: label });
+      });
+      tasks.push(task);
+    }
+    await Promise.all(tasks);
+    entries.clear();
+    recordsByKey.delete(key);
+    disposalFinished = true;
+    log2.info("state disposal completed", { key });
+  }
+  State2.dispose = dispose;
+})(State || (State = {}));
+
+// packages/opencode/src/project/instance.ts
+var context = Context.create("instance");
+var cache2 = /* @__PURE__ */ new Map();
+var disposal = {
+  all: void 0
+};
+function emit(directory) {
+  GlobalBus.emit("event", {
+    directory,
+    payload: {
+      type: "server.instance.disposed",
+      properties: {
+        directory
+      }
+    }
+  });
+}
+function boot(input) {
+  return iife(async () => {
+    const ctx = input.project && input.worktree ? {
+      directory: input.directory,
+      worktree: input.worktree,
+      project: input.project
+    } : await Project.fromDirectory(input.directory).then(({ project, sandbox }) => ({
+      directory: input.directory,
+      worktree: sandbox,
+      project
+    }));
+    await context.provide(ctx, async () => {
+      await input.init?.();
+    });
+    return ctx;
+  });
+}
+function track(directory, next) {
+  const task = next.catch((error) => {
+    if (cache2.get(directory) === task) cache2.delete(directory);
+    throw error;
+  });
+  cache2.set(directory, task);
+  return task;
+}
+var Instance = {
+  async provide(input) {
+    const directory = Filesystem.resolve(input.directory);
+    let existing = cache2.get(directory);
+    if (!existing) {
+      Log.Default.info("creating instance", { directory });
+      existing = track(
+        directory,
+        boot({
+          directory,
+          init: input.init
+        })
+      );
+    }
+    const ctx = await existing;
+    return context.provide(ctx, async () => {
+      return input.fn();
+    });
+  },
+  get current() {
+    return context.use();
+  },
+  get directory() {
+    return context.use().directory;
+  },
+  get worktree() {
+    return context.use().worktree;
+  },
+  get project() {
+    return context.use().project;
+  },
+  /**
+   * Check if a path is within the project boundary.
+   * Returns true if path is inside Instance.directory OR Instance.worktree.
+   * Paths within the worktree but outside the working directory should not trigger external_directory permission.
+   */
+  containsPath(filepath) {
+    if (Filesystem.contains(Instance.directory, filepath)) return true;
+    if (Instance.worktree === "/") return false;
+    return Filesystem.contains(Instance.worktree, filepath);
+  },
+  /**
+   * Captures the current instance ALS context and returns a wrapper that
+   * restores it when called. Use this for callbacks that fire outside the
+   * instance async context (native addons, event emitters, timers, etc.).
+   */
+  bind(fn) {
+    const ctx = context.use();
+    return ((...args) => context.provide(ctx, () => fn(...args)));
+  },
+  /**
+   * Run a synchronous function within the given instance context ALS.
+   * Use this to bridge from Effect (where InstanceRef carries context)
+   * back to sync code that reads Instance.directory from ALS.
+   */
+  restore(ctx, fn) {
+    return context.provide(ctx, fn);
+  },
+  state(init2, dispose) {
+    return State.create(() => Instance.directory, init2, dispose);
+  },
+  async reload(input) {
+    const directory = Filesystem.resolve(input.directory);
+    Log.Default.info("reloading instance", { directory });
+    await Promise.all([State.dispose(directory), disposeInstance(directory)]);
+    cache2.delete(directory);
+    const next = track(directory, boot({ ...input, directory }));
+    emit(directory);
+    return await next;
+  },
+  async dispose() {
+    const directory = Instance.directory;
+    Log.Default.info("disposing instance", { directory });
+    await Promise.all([State.dispose(directory), disposeInstance(directory)]);
+    cache2.delete(directory);
+    emit(directory);
+  },
+  async disposeAll() {
+    if (disposal.all) return disposal.all;
+    disposal.all = iife(async () => {
+      Log.Default.info("disposing all instances");
+      const entries = [...cache2.entries()];
+      for (const [key, value] of entries) {
+        if (cache2.get(key) !== value) continue;
+        const ctx = await value.catch((error) => {
+          Log.Default.warn("instance dispose failed", { key, error });
+          return void 0;
+        });
+        if (!ctx) {
+          if (cache2.get(key) === value) cache2.delete(key);
+          continue;
+        }
+        if (cache2.get(key) !== value) continue;
+        await context.provide(ctx, async () => {
+          await Instance.dispose();
+        });
+      }
+    }).finally(() => {
+      disposal.all = void 0;
+    });
+    return disposal.all;
+  }
+};
+
+// packages/opencode/src/effect/run-service.ts
+var memoMap = Layer4.makeMemoMapUnsafe();
+function attach(effect2) {
+  try {
+    const ctx = Instance.current;
+    return Effect5.provideService(effect2, InstanceRef, ctx);
+  } catch (err) {
+    if (!(err instanceof Context.NotFound)) throw err;
+  }
+  return effect2;
+}
+function makeRuntime(service, layer3) {
+  let rt2;
+  const getRuntime = () => rt2 ??= ManagedRuntime.make(layer3, { memoMap });
+  return {
+    runSync: (fn) => getRuntime().runSync(attach(service.use(fn))),
+    runPromiseExit: (fn, options) => getRuntime().runPromiseExit(attach(service.use(fn)), options),
+    runPromise: (fn, options) => getRuntime().runPromise(attach(service.use(fn)), options),
+    runFork: (fn) => getRuntime().runFork(attach(service.use(fn))),
+    runCallback: (fn) => getRuntime().runCallback(attach(service.use(fn)))
+  };
+}
+
+export {
+  Glob,
+  Filesystem,
+  Global,
+  Log,
+  GlobalBus,
+  iife,
+  lazy,
+  NamedError,
+  Flag,
+  VERSION,
+  CHANNEL,
+  InstanceState,
+  NotFoundError,
+  Database,
+  db_exports,
+  Timestamps,
+  ProjectTable,
+  SessionTable,
+  MessageTable,
+  PartTable,
+  TodoTable,
+  PermissionTable,
+  BusEvent,
+  which,
+  ProjectID,
+  AppFileSystem,
+  defaultLayer,
+  runPromiseExit,
+  Project,
+  Instance,
+  memoMap,
+  makeRuntime
+};
+//# sourceMappingURL=chunk-CMAI7CAJ.js.map