@kitman-sh/cli 0.9.0 → 0.10.53

package/dist/chunk-x0b92bjb.js

@@ -0,0 +1,222 @@
+// @bun
+import {
+  getOrUndefined,
+  liftThrowable,
+  TaggedError,
+  all3,
+  suspend3,
+  void_3,
+  gen,
+  fail7,
+  try_2,
+  mapError2,
+  timeoutOrElse,
+  scoped,
+  declare,
+  decodeEffect,
+  String4,
+  Boolean2,
+  Struct,
+  ArraySchema,
+  Literals,
+  NullOr,
+  Finite,
+  encodeUnknownJsonStringSync
+} from "./chunk-mbctzx7e.js";
+import {
+  isNumber,
+  isJsonObject,
+  isString
+} from "./chunk-arvwar2c.js";
+import {
+  make11,
+  runForEach,
+  compiled2
+} from "./chunk-11p4wf6n.js";
+import {
+  ChildProcessSpawner,
+  make7
+} from "./chunk-3bj7sc3v.js";
+
+// packages/agent-runtime/src/opencode-store.ts
+import { lstatSync, readFileSync, realpathSync } from "fs";
+import { DatabaseSync } from "node:sqlite";
+import { fileURLToPath } from "url";
+class OpencodeReadFailed extends TaggedError("OpencodeReadFailed") {
+  get message() {
+    return `OpenCode's session could not be read: ${this.reason}`;
+  }
+}
+var sliceBytes2 = 1024 * 1024;
+var maxLineBytes2 = 8 * 1024 * 1024;
+var linesPerTurn2 = 1024;
+var decodedOption2 = liftThrowable((text) => JSON.parse(text));
+var decoded2 = (text) => getOrUndefined(decodedOption2(text));
+var Parsed = declare((_value) => true);
+var OpencodeV2PartSchema = Struct({ ordinal: Finite, part: Parsed });
+var OpencodeV2MessageSchema = Struct({
+  id: String4,
+  seq: Finite,
+  closed: Boolean2,
+  parts: NullOr(ArraySchema(OpencodeV2PartSchema))
+});
+var PartSchema = Struct({
+  id: String4,
+  position: Finite,
+  role: NullOr(String4),
+  part: Parsed
+});
+var maxRoleChars = 64;
+var maxPartsPerMessage = 4096;
+var bytesOf = (column) => `length(cast(${column} as blob))`;
+var unlessLong = (column) => `case when ${bytesOf(column)} <= ${maxLineBytes2} then ${column} end`;
+var decodedParts = (db, ids) => {
+  const statement = db.prepare(`select part.rowid as position, ${unlessLong("message.data")} as message, ${unlessLong("part.data")} as part from part join message on message.id = part.message_id where part.id = ?`);
+  const parts = [];
+  let bytes = 0;
+  let reached = 0;
+  while (reached < ids.length && bytes < sliceBytes2) {
+    const id = ids[reached++];
+    const row = id === undefined ? undefined : statement.get(id);
+    if (id !== undefined && isNumber(row?.position)) {
+      const message = isString(row.message) ? decoded2(row.message) : undefined;
+      const part = isString(row.part) ? decoded2(row.part) : undefined;
+      bytes += isString(row.part) ? row.part.length : 0;
+      const role = isJsonObject(message) ? message.role : undefined;
+      const shortRole = isString(role) && role.length <= maxRoleChars ? role : null;
+      parts.push({ id, position: row.position, role: shortRole, part: part ?? null });
+    }
+  }
+  return { parts, rest: ids.slice(reached) };
+};
+var partsPast = "from part join message on message.id = part.message_id where part.session_id = ? and part.rowid > ?";
+var opencodeV2Parts = (db, hasPartTable, id, data) => {
+  const rows = hasPartTable ? db.prepare("select ordinal, data from session_part where message_id = ? order by ordinal").all(id) : [];
+  if (rows.length > 0)
+    return rows.flatMap((row) => isNumber(row.ordinal) && isString(row.data) ? [{ ordinal: row.ordinal, part: decoded2(row.data) ?? null }] : []);
+  const content = isJsonObject(data) ? data.content : undefined;
+  return Array.isArray(content) ? content.map((part, ordinal) => ({ ordinal, part })) : [];
+};
+var opencodeSessionTables = [
+  { table: "session_v2", kind: "opencode_v2" },
+  { table: "session", kind: "opencode" }
+];
+var reading = (output, read) => ({
+  output,
+  read
+});
+var readings = {
+  newestSession: reading(NullOr(Struct({ kind: Literals(["opencode", "opencode_v2"]), id: String4, createdAt: Finite })), (db, { worktree, startedAt }) => {
+    const present = new Set(db.prepare("select name from sqlite_master where type = 'table'").all().map((row) => row.name));
+    const newest = opencodeSessionTables.filter(({ table }) => present.has(table)).flatMap(({ table, kind }) => {
+      const row = db.prepare(`select id, time_created from ${table} where directory = ? and parent_id is null and time_created >= ? order by time_created desc limit 1`).get(worktree, startedAt);
+      return isString(row?.id) && isNumber(row.time_created) ? [{ kind, id: row.id, createdAt: row.time_created }] : [];
+    });
+    return newest.reduce((best, session) => best === null || session.createdAt > best.createdAt ? session : best, null);
+  }),
+  parts: reading(Struct({ parts: ArraySchema(PartSchema), rest: ArraySchema(String4) }), (db, { ids }) => decodedParts(db, ids)),
+  partsPast: reading(ArraySchema(PartSchema), (db, { position }, sessionId) => {
+    const rows = db.prepare(`select part.id as id ${partsPast} order by part.rowid limit ?`).all(sessionId, position, linesPerTurn2);
+    return decodedParts(db, rows.flatMap((row) => isString(row.id) ? [row.id] : [])).parts;
+  }),
+  partsPastCount: reading(Finite, (db, { position }, sessionId) => Number(db.prepare(`select count(*) as parts ${partsPast}`).get(sessionId, position)?.parts)),
+  messagesPast: reading(ArraySchema(OpencodeV2MessageSchema), (db, { seq }, sessionId) => {
+    const hasPartTable = db.prepare("select 1 from sqlite_master where name = 'session_part'").get() !== undefined;
+    const size = hasPartTable ? `${bytesOf("data")} + coalesce((select sum(${bytesOf("data")}) from session_part where message_id = session_message.id), 0)` : bytesOf("data");
+    const found = db.prepare(`select id, seq, ${size} as size, json_extract(data, '$.time.completed') is not null as completed from session_message where session_id = ? and type = 'assistant' and seq > ? order by seq limit ?`).all(sessionId, seq, linesPerTurn2 + 1);
+    const read = db.prepare("select data from session_message where id = ?");
+    const messages = [];
+    let bytes = 0;
+    for (const [index, row] of found.slice(0, linesPerTurn2).entries()) {
+      if (bytes >= sliceBytes2)
+        break;
+      if (!isString(row.id) || !isNumber(row.seq) || !isNumber(row.size))
+        continue;
+      const closed = row.completed === 1 || index < found.length - 1;
+      if (row.size > maxLineBytes2) {
+        messages.push({ id: row.id, seq: row.seq, closed, parts: null });
+        continue;
+      }
+      const data = read.get(row.id)?.data;
+      bytes += row.size;
+      const parts = opencodeV2Parts(db, hasPartTable, row.id, isString(data) ? decoded2(data) : undefined);
+      messages.push({ id: row.id, seq: row.seq, closed, parts: parts.length > maxPartsPerMessage ? null : parts });
+    }
+    return messages;
+  }),
+  extent: reading(Finite, (db, _input, sessionId) => Number(db.prepare(`with recursive sessions(id) as (select ? union select session_v2.id from session_v2 join sessions on session_v2.parent_id = sessions.id)
+           select coalesce(max(time_updated), 0) as extent from session_message where session_id in sessions`).get(sessionId)?.extent))
+};
+var maxReaderHeapBytes = 256 * 1024 * 1024;
+var inDatabase = (database, hostile, use) => {
+  const db = new DatabaseSync(database, { readOnly: true });
+  try {
+    if (hostile)
+      db.exec(`pragma trusted_schema = off; pragma query_only = on; pragma hard_heap_limit = ${maxReaderHeapBytes};`);
+    return use(db);
+  } finally {
+    db.close();
+  }
+};
+var maxAnswerBytes = 16 * 1024 * 1024;
+var answerTimeout = "3 seconds";
+var opencodeReaderCommand = () => compiled2 ? [process.execPath, "opencode-read"] : [process.execPath, fileURLToPath(import.meta.resolve("./opencode-reader.main.ts"))];
+var isolatedRead = (store, name, input) => gen(function* () {
+  const spawner = yield* ChildProcessSpawner;
+  const [command, ...args] = opencodeReaderCommand();
+  const handle = yield* spawner.spawn(make7(command, args, {
+    stdin: make11(new TextEncoder().encode(encodeUnknownJsonStringSync({ store, name, input }))),
+    stderr: "ignore",
+    extendEnv: false,
+    env: {},
+    killSignal: "SIGKILL"
+  }));
+  const chunks = [];
+  let bytes = 0;
+  const [, exitCode] = yield* all3([
+    runForEach(handle.stdout, (chunk) => suspend3(() => {
+      bytes += chunk.length;
+      chunks.push(chunk);
+      return bytes > maxAnswerBytes ? fail7(new OpencodeReadFailed({ reason: "the reader said too much" })) : void_3;
+    })),
+    handle.exitCode
+  ], { concurrency: 2 });
+  if (exitCode !== 0)
+    return yield* new OpencodeReadFailed({ reason: `the reader exited with ${exitCode}` });
+  const answer = decoded2(new TextDecoder().decode(Buffer.concat(chunks)));
+  return yield* decodeEffect(readings[name].output)(answer);
+}).pipe(scoped, mapError2((error) => error instanceof OpencodeReadFailed ? error : new OpencodeReadFailed({ reason: error.message })), timeoutOrElse({
+  duration: answerTimeout,
+  orElse: () => fail7(new OpencodeReadFailed({ reason: "the reader did not answer in time" }))
+}));
+var readOpencode2 = (store, name, input) => store.confinedTo === undefined ? try_2({
+  try: () => answerFrom(store, name, input, false),
+  catch: (error) => new OpencodeReadFailed({ reason: String(error) })
+}) : isolatedRead(store, name, input);
+var answerFrom = (store, name, input, hostile) => inDatabase(store.database, hostile, (db) => readings[name].read(db, input, store.sessionId ?? ""));
+var assertConfined = (database, root) => {
+  for (const file of [database, `${database}-wal`, `${database}-shm`, `${database}-journal`]) {
+    const stat = lstatSync(file, { throwIfNoEntry: false });
+    if (file === database && stat === undefined)
+      throw new Error("No database");
+    if (stat !== undefined && (!stat.isFile() || stat.nlink !== 1))
+      throw new Error("Not a plain file");
+  }
+  if (!realpathSync(database).startsWith(`${realpathSync(root)}/`))
+    throw new Error("Outside its directory");
+};
+var runOpencodeReader2 = () => {
+  const request = decoded2(readFileSync(0, "utf8"));
+  if (!isJsonObject(request) || !isJsonObject(request.store))
+    throw new Error("No request");
+  const { database, sessionId, confinedTo } = request.store;
+  if (!isString(database) || !isString(confinedTo))
+    throw new Error("No confined database");
+  assertConfined(database, confinedTo);
+  const store = { database, confinedTo, ...isString(sessionId) ? { sessionId } : undefined };
+  const reading = request.name;
+  const input = request.input;
+  process.stdout.write(encodeUnknownJsonStringSync(answerFrom(store, reading, input, true)));
+};
+
+export { sliceBytes2, maxLineBytes2, linesPerTurn2, decodedOption2, decoded2, readOpencode2, runOpencodeReader2 };