forge-cw 0.1.7 → 0.1.8

package/dist/index.js

@@ -1526,9 +1526,9 @@ var init_login_manager = __esm({
       cwBin;
       spawn;
       entries = /* @__PURE__ */ new Map();
-      constructor(cwBin, spawn7 = spawnInPty) {
+      constructor(cwBin, spawn8 = spawnInPty) {
         this.cwBin = cwBin;
-        this.spawn = spawn7;
+        this.spawn = spawn8;
       }
       start(account, harness) {
         const key = `${account}::${harness}`;
@@ -3932,20 +3932,375 @@ var init_liveframe_routes = __esm({
   }
 });
 
-// ../core/dist/server.js
+// ../core/dist/cw-install.js
+import { execFile as execFile5 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { accessSync as accessSync2, constants as constants2, existsSync as existsSync11, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { delimiter as delimiter2, join as join12 } from "node:path";
+function readCwVersion(file) {
+  try {
+    const match = /^CW_VERSION="([^"]+)"/m.exec(readFileSync9(file, "utf-8"));
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+function readCwBundle(dir) {
+  try {
+    const { ref } = JSON.parse(readFileSync9(join12(dir, ".bundle.json"), "utf-8"));
+    const version = readCwVersion(join12(dir, "cw"));
+    if (!ref || !version || !existsSync11(join12(dir, "install.sh")))
+      return null;
+    return { dir, version, ref };
+  } catch {
+    return null;
+  }
+}
+function decideCwInstall({ bundle, installed, marker, cwOnPath, skip }) {
+  if (skip)
+    return { action: "skip", reason: "FORGE_SKIP_CW_INSTALL is set" };
+  if (!bundle)
+    return { action: "skip", reason: "this Forge carries no CW" };
+  if (!installed) {
+    return cwOnPath ? { action: "skip", reason: "using the cw found on PATH" } : { action: "install", reason: "CW is not installed" };
+  }
+  if (!installed.version)
+    return { action: "skip", reason: "cannot read the installed CW version" };
+  const newer = compareVersions(bundle.version, installed.version);
+  const ownedByForge = marker !== null && marker.sha256 === installed.sha256;
+  if (ownedByForge) {
+    if (marker.ref === bundle.ref)
+      return { action: "skip", reason: `CW ${installed.version} is current` };
+    return newer >= 0 ? { action: "update", reason: `CW ${installed.version} \u2192 ${bundle.version}` } : { action: "skip", reason: `installed CW ${installed.version} is newer than ${bundle.version}` };
+  }
+  return newer > 0 ? { action: "update", reason: `CW ${installed.version} \u2192 ${bundle.version}` } : { action: "skip", reason: `CW ${installed.version} is current` };
+}
+function findOnPath(name, pathVar, excludeDir) {
+  for (const dir of (pathVar ?? "").split(delimiter2)) {
+    if (!dir || dir === excludeDir)
+      continue;
+    const candidate = join12(dir, name);
+    try {
+      if (!statSync3(candidate).isFile())
+        continue;
+      accessSync2(candidate, constants2.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function pathWithCw(cwHome, pathVar) {
+  const bin = join12(cwHome, "bin");
+  const rest = (pathVar ?? "").split(delimiter2).filter((dir) => dir && dir !== bin);
+  return [bin, ...rest].join(delimiter2);
+}
+function readMarker(cwHome) {
+  try {
+    return JSON.parse(readFileSync9(join12(cwHome, MARKER_FILE), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function failureMessage2(output) {
+  const lines2 = output.replace(ANSI_RE3, "").split("\n").map((l) => l.trim()).filter(Boolean);
+  const errors = lines2.filter((l) => l.startsWith("[\u2717]")).map((l) => l.slice(3).trim());
+  return (errors.length > 0 ? errors : lines2.slice(-3)).join(" ") || "the CW installer failed";
+}
+async function ensureCw(options) {
+  const { cwHome, bundleDir } = options;
+  const env = options.env ?? process.env;
+  const run = options.run ?? runInstall;
+  const bin = join12(cwHome, "bin", "cw");
+  const bundle = readCwBundle(bundleDir);
+  const installed = existsSync11(bin) ? { version: readCwVersion(bin), sha256: sha256Of(bin) } : null;
+  const decision = decideCwInstall({
+    bundle,
+    installed,
+    marker: readMarker(cwHome),
+    cwOnPath: findOnPath("cw", env.PATH, join12(cwHome, "bin")) !== null,
+    skip: env.FORGE_SKIP_CW_INSTALL === "1"
+  });
+  if (decision.action === "skip" || !bundle)
+    return { action: "skipped", message: decision.reason };
+  const { code, output } = await run(join12(bundle.dir, "install.sh"), ["--no-shell"], { ...env, CW_HOME: cwHome });
+  if (code !== 0 || !existsSync11(bin))
+    return { action: "failed", message: failureMessage2(output) };
+  const marker = { version: bundle.version, ref: bundle.ref, sha256: sha256Of(bin) };
+  writeFileSync4(join12(cwHome, MARKER_FILE), JSON.stringify(marker, null, 2) + "\n");
+  return {
+    action: decision.action === "install" ? "installed" : "updated",
+    version: bundle.version,
+    message: decision.reason
+  };
+}
+var MARKER_FILE, INSTALL_TIMEOUT_MS2, ANSI_RE3, sha256Of, runInstall;
+var init_cw_install = __esm({
+  "../core/dist/cw-install.js"() {
+    "use strict";
+    MARKER_FILE = ".forge-cw.json";
+    INSTALL_TIMEOUT_MS2 = 12e4;
+    ANSI_RE3 = /\u001b\[[0-9;?]*[A-Za-z]/g;
+    sha256Of = (file) => createHash2("sha256").update(readFileSync9(file)).digest("hex");
+    runInstall = (script, args, env) => new Promise((resolve5) => {
+      execFile5("bash", [script, ...args], { env, timeout: INSTALL_TIMEOUT_MS2, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+        const output = `${String(stdout)}${String(stderr)}`;
+        if (!err)
+          return resolve5({ code: 0, output });
+        const code = err.code;
+        resolve5({ code: typeof code === "number" ? code : 1, output: output || err.message });
+      });
+    });
+  }
+});
+
+// ../core/dist/kioku.js
+import { spawn as spawn7 } from "node:child_process";
+import { existsSync as existsSync12 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join13 } from "node:path";
+import { createInterface } from "node:readline";
+function resolveKiokuBin(pathVar = process.env.PATH, home = homedir5()) {
+  const fallback = join13(home, ".local", "bin", "kioku");
+  return findOnPath("kioku", pathVar) ?? (existsSync12(fallback) ? fallback : "kioku");
+}
+function parseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function mapLimit(items, limit, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const i = next++;
+      out[i] = await fn(items[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return out;
+}
+var KiokuError, NOT_INSTALLED, START_TIMEOUT_MS, CACHE_MS2, ACTIVITY_SINCE, ACTIVITY_LIMIT, PARALLEL, MISSING, brainName, Kioku;
+var init_kioku = __esm({
+  "../core/dist/kioku.js"() {
+    "use strict";
+    init_task_review();
+    init_cw_install();
+    init_output();
+    KiokuError = class extends Error {
+      status;
+      constructor(message, status = 502) {
+        super(message);
+        this.status = status;
+      }
+    };
+    NOT_INSTALLED = "kioku is not installed on this machine";
+    START_TIMEOUT_MS = 2e4;
+    CACHE_MS2 = 5 * 6e4;
+    ACTIVITY_SINCE = "2w";
+    ACTIVITY_LIMIT = 40;
+    PARALLEL = 6;
+    MISSING = { installed: false, version: null, brains: [], projects: {}, activity: [] };
+    brainName = (b) => b.name ?? b.key;
+    Kioku = class {
+      run;
+      startTimeoutMs;
+      projects;
+      now;
+      binPath;
+      viewer = null;
+      snapshot = null;
+      constructor(options = {}) {
+        this.binPath = options.bin;
+        this.run = options.run ?? createRunner();
+        this.startTimeoutMs = options.startTimeoutMs ?? START_TIMEOUT_MS;
+        this.projects = options.projects ?? (() => ({}));
+        this.now = options.now ?? Date.now;
+      }
+      // resolved on first use, so a Forge that never opens Memory does not search PATH
+      get bin() {
+        return this.binPath ??= resolveKiokuBin();
+      }
+      async status(fresh = false) {
+        const previous = this.snapshot;
+        if (fresh || !previous || this.now() - previous.at > CACHE_MS2) {
+          const value = this.read();
+          this.snapshot = { at: this.now(), value };
+          value.catch(() => {
+            if (this.snapshot?.value === value)
+              this.snapshot = previous;
+          });
+        }
+        const pending = fresh || !previous ? this.snapshot.value : previous.value;
+        const [snapshot, viewer] = await Promise.all([pending, this.viewer?.catch(() => null) ?? null]);
+        return { ...snapshot, viewer: viewer?.address ?? null };
+      }
+      async json(args, cwd) {
+        const result2 = await this.run(this.bin, [...args, "--json"], cwd);
+        return result2.code === 0 ? parseJson(result2.stdout) : null;
+      }
+      async read() {
+        const [version, list] = await Promise.all([
+          this.run(this.bin, ["--version"], homedir5()),
+          this.json(["brain", "list"], homedir5())
+        ]);
+        if (version.code !== 0)
+          return MISSING;
+        const listed = list?.brains ?? [];
+        const entries = Object.entries(this.projects()).filter(([, p]) => existsSync12(p.path));
+        const readBrain = async (b) => {
+          if (!b.onDisk)
+            return { kinds: {}, writes: [] };
+          const [ns, log] = await Promise.all([
+            this.json(["namespace", "list", "--brain", b.key], b.folder),
+            this.json(["brain", "log", "--since", ACTIVITY_SINCE, "--brain", b.key], b.folder)
+          ]);
+          const kinds = {};
+          for (const n of ns?.brains?.find((x) => x.brain === brainName(b))?.namespaces ?? []) {
+            for (const [kind, count] of Object.entries(n.pages))
+              kinds[kind] = (kinds[kind] ?? 0) + count;
+          }
+          return { kinds, writes: log?.writes ?? [] };
+        };
+        const readChain = async (path) => (await this.json(["brain", "list"], path))?.chain ?? [];
+        const [perBrain, chains] = await Promise.all([
+          mapLimit(listed, PARALLEL / 2, readBrain),
+          mapLimit(entries, PARALLEL / 2, ([, p]) => readChain(p.path))
+        ]);
+        const activity = perBrain.flatMap((p) => p.writes).sort((x, y) => y.date.localeCompare(x.date));
+        const brains = listed.map((b, i) => {
+          const { kinds } = perBrain[i];
+          const name = brainName(b);
+          return {
+            ...b,
+            pages: Object.values(kinds).reduce((sum, n) => sum + n, 0),
+            kinds,
+            touched: activity.find((w) => w.brain === name)?.date ?? null
+          };
+        });
+        const projects = Object.fromEntries(entries.map(([name], i) => [name, chains[i].map(({ name: name2, tier }) => ({ name: name2, tier }))]));
+        return {
+          installed: true,
+          version: parseJson(version.stdout)?.version ?? null,
+          brains,
+          projects,
+          activity: activity.slice(0, ACTIVITY_LIMIT).map(({ verb, title, path, date, author, brain }) => ({ verb, title, path, date, author, brain }))
+        };
+      }
+      // one viewer at a time; a second call reuses the running one
+      async openViewer() {
+        this.viewer ??= this.startViewer();
+        return (await this.viewer).address;
+      }
+      startViewer() {
+        const started = new Promise((resolve5, reject) => {
+          const child = spawn7(this.bin, ["web", "--json", "--no-open"], { cwd: homedir5(), stdio: ["ignore", "pipe", "pipe"] });
+          const lines2 = createInterface({ input: child.stdout });
+          let stderr = "";
+          let settled = false;
+          const finish = () => {
+            settled = true;
+            clearTimeout(timer);
+            lines2.close();
+            child.stdout?.resume();
+          };
+          const fail = (err) => {
+            if (settled)
+              return;
+            finish();
+            child.kill();
+            reject(err);
+          };
+          const timer = setTimeout(() => fail(new KiokuError("kioku web did not start in time")), this.startTimeoutMs);
+          child.stderr?.on("data", (chunk) => {
+            stderr = (stderr + chunk.toString()).slice(-4096);
+          });
+          lines2.on("line", (line) => {
+            const event = parseJson(line);
+            if (settled || event?.event !== "listening" || !event.address?.startsWith("http://127.0.0.1:"))
+              return;
+            finish();
+            resolve5({ child, address: event.address });
+          });
+          child.on("error", (err) => {
+            const missing = err.code === "ENOENT";
+            fail(new KiokuError(missing ? NOT_INSTALLED : err.message, missing ? 404 : 502));
+          });
+          child.on("exit", (code) => {
+            if (this.viewer === started)
+              this.viewer = null;
+            fail(new KiokuError(tailOutput(stderr, 1) || `kioku web exited with code ${code}`));
+          });
+        });
+        started.catch(() => {
+          if (this.viewer === started)
+            this.viewer = null;
+        });
+        return started;
+      }
+      stopViewer() {
+        void this.viewer?.then((v) => v.child.kill(), () => {
+        });
+        this.viewer = null;
+      }
+      dispose() {
+        this.stopViewer();
+      }
+    };
+  }
+});
+
+// ../core/dist/kioku-routes.js
 import { Hono as Hono4 } from "hono";
+function kiokuRoutes(kioku = new Kioku()) {
+  const app = new Hono4();
+  app.onError((err, c) => {
+    if (err instanceof KiokuError)
+      return c.json({ error: err.message }, err.status);
+    throw err;
+  });
+  app.get("/status", async (c) => c.json(await kioku.status(c.req.query("fresh") === "1")));
+  app.post("/viewer", async (c) => c.json({ address: await kioku.openViewer() }));
+  app.delete("/viewer", (c) => {
+    kioku.stopViewer();
+    return c.json({ ok: true });
+  });
+  return app;
+}
+var init_kioku_routes = __esm({
+  "../core/dist/kioku-routes.js"() {
+    "use strict";
+    init_kioku();
+  }
+});
+
+// ../core/dist/server.js
+import { Hono as Hono5 } from "hono";
 import { cors } from "hono/cors";
-import { join as join12, basename as basename3, resolve as resolve4 } from "node:path";
-import { readdirSync as readdirSync6, existsSync as existsSync11 } from "node:fs";
+import { join as join14, basename as basename3, resolve as resolve4 } from "node:path";
+import { readdirSync as readdirSync6, existsSync as existsSync13 } from "node:fs";
 function createForgeServer(options) {
   const { dataDir, db: externalDb, authToken, localOnly = true } = options;
-  const dbPath = join12(dataDir, "forge.db");
-  const modulesDir = join12(dataDir, "modules");
+  const dbPath = join14(dataDir, "forge.db");
+  const modulesDir = join14(dataDir, "modules");
   const db = externalDb ?? new ForgeDB(dbPath);
   const loader = new ModuleLoader(modulesDir, options.bundledModulesDir);
   const runner = new ActionRunner();
   loader.discover();
-  const app = new Hono4();
+  const app = new Hono5();
   app.use("*", localOnly ? localOriginGuard() : cors());
   if (authToken) {
     app.use("/api/*", bearerAuth(authToken));
@@ -3973,9 +4328,11 @@ function createForgeServer(options) {
     }
   });
   const ptyManager = new PTYManager(states);
-  const generalSessions = new GeneralSessions(join12(dataDir, "general-sessions.json"));
+  const generalSessions = new GeneralSessions(join14(dataDir, "general-sessions.json"));
   const terminalWss = createTerminalWss(ptyManager, cwReader, { localOnly, general: generalSessions });
   app.route("/api/liveframe", liveframeRoutes());
+  const kioku = new Kioku({ projects: () => cwReader.getProjects() });
+  app.route("/api/kioku", kiokuRoutes(kioku));
   app.get("/api/cw/session-states", (c) => c.json({ classifier: states.remoteName ?? "local", shadow: states.isShadow, states: states.snapshot() }));
   app.post("/api/cw/terminal/kill", async (c) => {
     const { project, sessionDir } = await c.req.json();
@@ -4131,21 +4488,21 @@ data: ${JSON.stringify(data)}
     if (!dir.startsWith(home)) {
       return c.json({ error: "Access denied: path must be within home directory" }, 403);
     }
-    if (!existsSync11(dir)) {
+    if (!existsSync13(dir)) {
       return c.json({ error: "Directory not found" }, 404);
     }
     try {
       const entries = readdirSync6(dir, { withFileTypes: true });
       const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => ({
         name: e.name,
-        path: join12(dir, e.name),
-        hasPackageJson: existsSync11(join12(dir, e.name, "package.json")),
-        hasGit: existsSync11(join12(dir, e.name, ".git"))
+        path: join14(dir, e.name),
+        hasPackageJson: existsSync13(join14(dir, e.name, "package.json")),
+        hasGit: existsSync13(join14(dir, e.name, ".git"))
       })).sort((a, b) => a.name.localeCompare(b.name));
       return c.json({
         current: dir,
         name: basename3(dir),
-        parent: join12(dir, ".."),
+        parent: join14(dir, ".."),
         directories: dirs
       });
     } catch {
@@ -4163,6 +4520,7 @@ data: ${JSON.stringify(data)}
       ptyManager.dispose();
       states.dispose();
       loginManager.dispose();
+      kioku.dispose();
       db.close();
     }
   };
@@ -4186,6 +4544,8 @@ var init_server = __esm({
     init_login_manager();
     init_general_sessions();
     init_liveframe_routes();
+    init_kioku_routes();
+    init_kioku();
   }
 });
 
@@ -4308,8 +4668,8 @@ async function createDatabase(opts) {
     await db.migrate();
     return db;
   }
-  const { join: join16 } = await import("node:path");
-  return new ForgeDB(join16(opts.dataDir, "forge.db"));
+  const { join: join17 } = await import("node:path");
+  return new ForgeDB(join17(opts.dataDir, "forge.db"));
 }
 var init_db_factory = __esm({
   "../core/dist/db-factory.js"() {
@@ -4319,22 +4679,22 @@ var init_db_factory = __esm({
 });
 
 // ../core/dist/init.js
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join13 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { existsSync as existsSync14, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join15 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 function getForgeDir() {
-  return join13(homedir5(), ".forge");
+  return join15(homedir6(), ".forge");
 }
 function ensureForgeDir() {
   const forgeDir = getForgeDir();
-  if (existsSync12(forgeDir)) {
+  if (existsSync14(forgeDir)) {
     return { forgeDir, created: false };
   }
   mkdirSync5(forgeDir, { recursive: true });
   for (const d of FORGE_SUBDIRS) {
-    mkdirSync5(join13(forgeDir, d), { recursive: true });
+    mkdirSync5(join15(forgeDir, d), { recursive: true });
   }
-  writeFileSync4(join13(forgeDir, "config.json"), JSON.stringify({
+  writeFileSync5(join15(forgeDir, "config.json"), JSON.stringify({
     port: 3e3,
     theme: "dark",
     openBrowser: true,
@@ -4350,138 +4710,6 @@ var init_init = __esm({
   }
 });
 
-// ../core/dist/cw-install.js
-import { execFile as execFile5 } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
-import { accessSync as accessSync2, constants as constants2, existsSync as existsSync13, readFileSync as readFileSync9, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { delimiter as delimiter2, join as join14 } from "node:path";
-function readCwVersion(file) {
-  try {
-    const match = /^CW_VERSION="([^"]+)"/m.exec(readFileSync9(file, "utf-8"));
-    return match ? match[1] : null;
-  } catch {
-    return null;
-  }
-}
-function compareVersions(a, b) {
-  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
-  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
-    if (diff !== 0)
-      return diff;
-  }
-  return 0;
-}
-function readCwBundle(dir) {
-  try {
-    const { ref } = JSON.parse(readFileSync9(join14(dir, ".bundle.json"), "utf-8"));
-    const version = readCwVersion(join14(dir, "cw"));
-    if (!ref || !version || !existsSync13(join14(dir, "install.sh")))
-      return null;
-    return { dir, version, ref };
-  } catch {
-    return null;
-  }
-}
-function decideCwInstall({ bundle, installed, marker, cwOnPath, skip }) {
-  if (skip)
-    return { action: "skip", reason: "FORGE_SKIP_CW_INSTALL is set" };
-  if (!bundle)
-    return { action: "skip", reason: "this Forge carries no CW" };
-  if (!installed) {
-    return cwOnPath ? { action: "skip", reason: "using the cw found on PATH" } : { action: "install", reason: "CW is not installed" };
-  }
-  if (!installed.version)
-    return { action: "skip", reason: "cannot read the installed CW version" };
-  const newer = compareVersions(bundle.version, installed.version);
-  const ownedByForge = marker !== null && marker.sha256 === installed.sha256;
-  if (ownedByForge) {
-    if (marker.ref === bundle.ref)
-      return { action: "skip", reason: `CW ${installed.version} is current` };
-    return newer >= 0 ? { action: "update", reason: `CW ${installed.version} \u2192 ${bundle.version}` } : { action: "skip", reason: `installed CW ${installed.version} is newer than ${bundle.version}` };
-  }
-  return newer > 0 ? { action: "update", reason: `CW ${installed.version} \u2192 ${bundle.version}` } : { action: "skip", reason: `CW ${installed.version} is current` };
-}
-function findOnPath(name, pathVar, excludeDir) {
-  for (const dir of (pathVar ?? "").split(delimiter2)) {
-    if (!dir || dir === excludeDir)
-      continue;
-    const candidate = join14(dir, name);
-    try {
-      if (!statSync3(candidate).isFile())
-        continue;
-      accessSync2(candidate, constants2.X_OK);
-      return candidate;
-    } catch {
-    }
-  }
-  return null;
-}
-function pathWithCw(cwHome, pathVar) {
-  const bin = join14(cwHome, "bin");
-  const rest = (pathVar ?? "").split(delimiter2).filter((dir) => dir && dir !== bin);
-  return [bin, ...rest].join(delimiter2);
-}
-function readMarker(cwHome) {
-  try {
-    return JSON.parse(readFileSync9(join14(cwHome, MARKER_FILE), "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function failureMessage2(output) {
-  const lines2 = output.replace(ANSI_RE3, "").split("\n").map((l) => l.trim()).filter(Boolean);
-  const errors = lines2.filter((l) => l.startsWith("[\u2717]")).map((l) => l.slice(3).trim());
-  return (errors.length > 0 ? errors : lines2.slice(-3)).join(" ") || "the CW installer failed";
-}
-async function ensureCw(options) {
-  const { cwHome, bundleDir } = options;
-  const env = options.env ?? process.env;
-  const run = options.run ?? runInstall;
-  const bin = join14(cwHome, "bin", "cw");
-  const bundle = readCwBundle(bundleDir);
-  const installed = existsSync13(bin) ? { version: readCwVersion(bin), sha256: sha256Of(bin) } : null;
-  const decision = decideCwInstall({
-    bundle,
-    installed,
-    marker: readMarker(cwHome),
-    cwOnPath: findOnPath("cw", env.PATH, join14(cwHome, "bin")) !== null,
-    skip: env.FORGE_SKIP_CW_INSTALL === "1"
-  });
-  if (decision.action === "skip" || !bundle)
-    return { action: "skipped", message: decision.reason };
-  const { code, output } = await run(join14(bundle.dir, "install.sh"), ["--no-shell"], { ...env, CW_HOME: cwHome });
-  if (code !== 0 || !existsSync13(bin))
-    return { action: "failed", message: failureMessage2(output) };
-  const marker = { version: bundle.version, ref: bundle.ref, sha256: sha256Of(bin) };
-  writeFileSync5(join14(cwHome, MARKER_FILE), JSON.stringify(marker, null, 2) + "\n");
-  return {
-    action: decision.action === "install" ? "installed" : "updated",
-    version: bundle.version,
-    message: decision.reason
-  };
-}
-var MARKER_FILE, INSTALL_TIMEOUT_MS2, ANSI_RE3, sha256Of, runInstall;
-var init_cw_install = __esm({
-  "../core/dist/cw-install.js"() {
-    "use strict";
-    MARKER_FILE = ".forge-cw.json";
-    INSTALL_TIMEOUT_MS2 = 12e4;
-    ANSI_RE3 = /\u001b\[[0-9;?]*[A-Za-z]/g;
-    sha256Of = (file) => createHash2("sha256").update(readFileSync9(file)).digest("hex");
-    runInstall = (script, args, env) => new Promise((resolve5) => {
-      execFile5("bash", [script, ...args], { env, timeout: INSTALL_TIMEOUT_MS2, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
-        const output = `${String(stdout)}${String(stderr)}`;
-        if (!err)
-          return resolve5({ code: 0, output });
-        const code = err.code;
-        resolve5({ code: typeof code === "number" ? code : 1, output: output || err.message });
-      });
-    });
-  }
-});
-
 // ../core/dist/port-in-use.js
 function waitForListening(server) {
   if (server.listening)
@@ -4537,6 +4765,8 @@ __export(dist_exports, {
   ForgeDB: () => ForgeDB,
   HARNESS_CAPABILITIES: () => HARNESS_CAPABILITIES,
   HARNESS_NAME_RE: () => HARNESS_NAME_RE,
+  Kioku: () => Kioku,
+  KiokuError: () => KiokuError,
   Liveframe: () => Liveframe,
   LiveframeError: () => LiveframeError,
   MODEL_NAME_RE: () => MODEL_NAME_RE,
@@ -4551,11 +4781,13 @@ __export(dist_exports, {
   ensureCw: () => ensureCw,
   ensureForgeDir: () => ensureForgeDir,
   getForgeDir: () => getForgeDir,
+  kiokuRoutes: () => kiokuRoutes,
   liveframeRoutes: () => liveframeRoutes,
   pathWithCw: () => pathWithCw,
   portInUseMessage: () => portInUseMessage,
   probePort: () => probePort,
   quietSqliteWarning: () => quietSqliteWarning,
+  resolveKiokuBin: () => resolveKiokuBin,
   resolveListenOptions: () => resolveListenOptions,
   skillRoutes: () => skillRoutes,
   supports: () => supports,
@@ -4584,14 +4816,16 @@ var init_dist = __esm({
     init_pty_routes();
     init_liveframe_routes();
     init_liveframe();
+    init_kioku_routes();
+    init_kioku();
     init_port_in_use();
   }
 });
 
 // src/index.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync10 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join16 } from "node:path";
 function parseArgs(argv) {
   const out = { open: true };
   for (let i = 0; i < argv.length; i++) {
@@ -4602,11 +4836,11 @@ function parseArgs(argv) {
   }
   return out;
 }
-var packageRoot = join15(import.meta.dirname, "..");
-var isCheckout = existsSync14(join15(packageRoot, "src"));
-var consoleDist = isCheckout ? join15(packageRoot, "../console/dist") : join15(packageRoot, "console");
-var forgeVersion = JSON.parse(readFileSync10(join15(packageRoot, "package.json"), "utf-8")).version;
-var bundledModulesDir = isCheckout ? join15(packageRoot, "../../modules") : join15(packageRoot, "modules");
+var packageRoot = join16(import.meta.dirname, "..");
+var isCheckout = existsSync15(join16(packageRoot, "src"));
+var consoleDist = isCheckout ? join16(packageRoot, "../console/dist") : join16(packageRoot, "console");
+var forgeVersion = JSON.parse(readFileSync10(join16(packageRoot, "package.json"), "utf-8")).version;
+var bundledModulesDir = isCheckout ? join16(packageRoot, "../../modules") : join16(packageRoot, "modules");
 async function main() {
   const { ensureForgeDir: ensureForgeDir2, createForgeServer: createForgeServer2, createDatabase: createDatabase2, resolveListenOptions: resolveListenOptions2, ensureCw: ensureCw2, pathWithCw: pathWithCw2, quietSqliteWarning: quietSqliteWarning2, waitForListening: waitForListening2, probePort: probePort2, portInUseMessage: portInUseMessage2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
   quietSqliteWarning2();
@@ -4615,8 +4849,8 @@ async function main() {
   if (created) {
     console.log("First run \u2014 initialized Forge.");
   }
-  const cwHome = join15(process.env.HOME ?? homedir6(), ".cw");
-  const cw = isCheckout ? { action: "skipped", message: "a checkout does not install CW" } : await ensureCw2({ cwHome, bundleDir: join15(packageRoot, "cw") });
+  const cwHome = join16(process.env.HOME ?? homedir7(), ".cw");
+  const cw = isCheckout ? { action: "skipped", message: "a checkout does not install CW" } : await ensureCw2({ cwHome, bundleDir: join16(packageRoot, "cw") });
   if (cw.action === "installed") console.log(`  Installed CW ${cw.version} in ${cwHome}`);
   else if (cw.action === "updated") console.log(`  Updated ${cw.message}`);
   else if (cw.action === "failed") console.log(`  Could not install CW: ${cw.message}`);
@@ -4641,9 +4875,9 @@ async function main() {
     version: forgeVersion
   });
   const { serveStatic } = await import("@hono/node-server/serve-static");
-  if (existsSync14(join15(consoleDist, "index.html"))) {
+  if (existsSync15(join16(consoleDist, "index.html"))) {
     server.app.use("/*", serveStatic({ root: consoleDist }));
-    const indexHtml = readFileSync10(join15(consoleDist, "index.html"), "utf-8");
+    const indexHtml = readFileSync10(join16(consoleDist, "index.html"), "utf-8");
     server.app.get("*", (c) => c.html(indexHtml));
   }
   const { serve } = await import("@hono/node-server");