@glrs-dev/cli 2.4.0 → 2.6.0

package/dist/node_modules/@glrs-dev/adapter-opencode/dist/index.js

@@ -0,0 +1,506 @@
+// src/opencode-adapter.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import * as fs from "fs";
+import {
+  createOpencode
+} from "@opencode-ai/sdk";
+var execFileP = promisify(execFile);
+var DEFAULT_STARTUP_TIMEOUT_MS = 3e4;
+async function ensureOpencodeOnPath() {
+  try {
+    await execFileP("opencode", ["--version"]);
+  } catch {
+    throw new Error(
+      "opencode CLI not found on PATH.\n  Install: https://opencode.ai\n  Or: bunx opencode upgrade"
+    );
+  }
+}
+async function startServer(opts) {
+  await ensureOpencodeOnPath();
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS;
+  const port = opts.port ?? 0;
+  const priorEnvValue = process.env["GLRS_AGENT_OVERRIDES"];
+  try {
+    if (opts.agentOverrides) {
+      process.env["GLRS_AGENT_OVERRIDES"] = JSON.stringify(opts.agentOverrides);
+    }
+    const { client, server } = await createOpencode({
+      port,
+      timeout: timeoutMs,
+      hostname: "127.0.0.1"
+    });
+    let shutdownCalled = false;
+    const shutdown = async () => {
+      if (shutdownCalled) return;
+      shutdownCalled = true;
+      try {
+        server.close();
+      } catch {
+      }
+      if (priorEnvValue === void 0) {
+        delete process.env["GLRS_AGENT_OVERRIDES"];
+      } else {
+        process.env["GLRS_AGENT_OVERRIDES"] = priorEnvValue;
+      }
+    };
+    return { url: server.url, client, shutdown };
+  } catch (err) {
+    if (priorEnvValue === void 0) {
+      delete process.env["GLRS_AGENT_OVERRIDES"];
+    } else {
+      process.env["GLRS_AGENT_OVERRIDES"] = priorEnvValue;
+    }
+    throw err;
+  }
+}
+async function selfTest(client) {
+  try {
+    await client.session.list();
+  } catch (err) {
+    throw new Error(
+      `OpenCode server self-test failed \u2014 the server started but isn't responding to API calls.
+  Error: ${err instanceof Error ? err.message : String(err)}
+  Run \`opencode --version\` to verify your installation.`
+    );
+  }
+}
+async function createSession(client, opts) {
+  const result = await client.session.create({
+    query: { directory: opts.cwd },
+    body: {}
+  });
+  if (!result.data) {
+    throw new Error("session.create returned no data");
+  }
+  return result.data.id;
+}
+async function sendAndWait(client, opts) {
+  const stallMs = opts.stallMs ?? 60 * 60 * 1e3;
+  const idlePromise = waitForIdle(client, {
+    sessionId: opts.sessionId,
+    stallMs,
+    abortSignal: opts.abortSignal,
+    onToolCall: opts.onToolCall,
+    onTextDelta: opts.onTextDelta,
+    onCostUpdate: opts.onCostUpdate,
+    autoRejectPermissions: opts.autoRejectPermissions,
+    serverUrl: opts.serverUrl,
+    onPermissionRejected: opts.onPermissionRejected
+  });
+  await client.session.prompt({
+    path: { id: opts.sessionId },
+    body: {
+      parts: [{ type: "text", text: opts.message }],
+      ...opts.agentName ? { agent: opts.agentName } : {}
+    }
+  });
+  return idlePromise;
+}
+async function waitForIdle(client, opts) {
+  const stallMs = opts.stallMs ?? 60 * 60 * 1e3;
+  const sse = await client.event.subscribe();
+  const reportedToolCalls = /* @__PURE__ */ new Set();
+  let sseFd = null;
+  if (process.env["GLRS_DEBUG_SSE"] === "1") {
+    try {
+      sseFd = fs.openSync("/tmp/glrs-sse.log", "a");
+    } catch {
+    }
+  }
+  const sseLog = (msg) => {
+    if (sseFd !== null) {
+      try {
+        fs.writeSync(sseFd, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+`);
+      } catch {
+      }
+    }
+  };
+  return new Promise((resolve) => {
+    let stallTimer = null;
+    let settled = false;
+    let pollerRunning = true;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      pollerRunning = false;
+      if (stallTimer) clearTimeout(stallTimer);
+      if (sseFd !== null) {
+        try {
+          fs.closeSync(sseFd);
+        } catch {
+        }
+      }
+      resolve(result);
+    };
+    const resetStall = () => {
+      if (stallTimer) clearTimeout(stallTimer);
+      stallTimer = setTimeout(() => settle({ kind: "stall", stallMs }), stallMs);
+    };
+    if (opts.abortSignal) {
+      if (opts.abortSignal.aborted) {
+        settle({ kind: "abort" });
+        return;
+      }
+      opts.abortSignal.addEventListener("abort", () => settle({ kind: "abort" }), { once: true });
+    }
+    resetStall();
+    if (opts.onToolCall) {
+      (async () => {
+        while (pollerRunning && !settled) {
+          await new Promise((r) => setTimeout(r, 2e3));
+          if (!pollerRunning || settled) break;
+          try {
+            const msgs = await client.session.messages({ path: { id: opts.sessionId } });
+            const messages = msgs?.data ?? msgs;
+            if (!Array.isArray(messages)) continue;
+            for (const msg of messages) {
+              if (msg?.info?.role !== "assistant") continue;
+              for (const part of msg?.parts ?? []) {
+                if (part?.type !== "tool") continue;
+                const callID = part.callID ?? part.id ?? "";
+                const status = part.state?.status ?? "";
+                const key = `${callID}:${status}`;
+                if (reportedToolCalls.has(key)) continue;
+                if (status !== "running" && status !== "completed" && status !== "error") continue;
+                reportedToolCalls.add(key);
+                resetStall();
+                const input = part.state?.input;
+                let firstArg;
+                if (input && typeof input === "object") {
+                  for (const k of ["filePath", "file_path", "path", "command", "pattern", "query"]) {
+                    const val = input[k];
+                    if (typeof val === "string" && val.length > 0) {
+                      firstArg = val.length > 80 ? val.slice(0, 77) + "..." : val;
+                      break;
+                    }
+                  }
+                }
+                try {
+                  opts.onToolCall(part.tool ?? "unknown", firstArg);
+                } catch {
+                }
+              }
+              if (opts.onCostUpdate && msg?.info?.cost > 0) {
+                const costKey = `cost:${msg.info.id}`;
+                if (!reportedToolCalls.has(costKey)) {
+                  reportedToolCalls.add(costKey);
+                }
+              }
+            }
+            if (opts.onCostUpdate) {
+              let totalCost = 0;
+              let totalIn = 0;
+              let totalOut = 0;
+              for (const m of messages) {
+                if (m?.info?.role === "assistant" && typeof m.info.cost === "number") {
+                  totalCost += m.info.cost;
+                  const t = m.info.tokens ?? {};
+                  totalIn += t.input ?? 0;
+                  totalOut += t.output ?? 0;
+                }
+              }
+              if (totalCost > 0) {
+                const costKey = `cumcost:${totalCost.toFixed(6)}`;
+                if (!reportedToolCalls.has(costKey)) {
+                  reportedToolCalls.add(costKey);
+                  try {
+                    opts.onCostUpdate(totalCost, { input: totalIn, output: totalOut });
+                  } catch {
+                  }
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      })();
+    }
+    (async () => {
+      try {
+        for await (const event of sse.stream) {
+          if (settled) break;
+          const ev = event;
+          const props = ev.properties ?? {};
+          const type = ev.type ?? "";
+          sseLog(`[SSE] type=${type}`);
+          if (opts.onCostUpdate && type === "message.updated") {
+            const info = props["info"];
+            if (info && info.role === "assistant" && typeof info.cost === "number") {
+              resetStall();
+              try {
+                opts.onCostUpdate(
+                  info.cost,
+                  {
+                    input: info.tokens?.input ?? 0,
+                    output: info.tokens?.output ?? 0
+                  }
+                );
+              } catch {
+              }
+            }
+          }
+          if (opts.onTextDelta && (type === "message.part.delta" || type === "message.part.updated")) {
+            const delta = props["delta"];
+            if (typeof delta === "string" && delta.length > 0) {
+              resetStall();
+              try {
+                opts.onTextDelta(delta.length);
+              } catch {
+              }
+            }
+          }
+          if (opts.onToolCall && (type === "message.part.updated" || type === "message.part.delta")) {
+            const part = props["part"];
+            if (part && part.type === "tool" && part.sessionID === opts.sessionId) {
+              const status = part.state?.status;
+              const hasCallId = !!part.callID;
+              const hasTool = !!part.tool;
+              const shouldFire = hasCallId && hasTool && !reportedToolCalls.has(part.callID) && (status === "completed" || // A: tool finished
+              status === "running" || // B: tool started
+              status === void 0);
+              sseLog(`[TOOL] type=${part.type} status=${status} tool=${part.tool} sessionMatch=${part.sessionID === opts.sessionId} callID=${part.callID} shouldFire=${shouldFire}`);
+              if (shouldFire) {
+                reportedToolCalls.add(part.callID);
+                resetStall();
+                let firstArg;
+                const input = part.state?.input;
+                if (input) {
+                  const argKeys = ["filePath", "file_path", "path", "command", "pattern", "query"];
+                  for (const key of argKeys) {
+                    const val = input[key];
+                    if (typeof val === "string" && val.length > 0) {
+                      firstArg = val.length > 80 ? val.slice(0, 77) + "..." : val;
+                      break;
+                    }
+                  }
+                }
+                try {
+                  opts.onToolCall(part.tool ?? "unknown", firstArg);
+                } catch {
+                }
+                continue;
+              }
+            }
+          }
+          const eventSessionId = props["sessionID"];
+          if (opts.autoRejectPermissions && (type === "permission.updated" || type === "question.asked")) {
+            const permissionId = props["id"];
+            const permissionType = type === "question.asked" ? "question" : props["type"] ?? "unknown";
+            const permissionTitle = props["title"] ?? "";
+            if (opts.onPermissionRejected) {
+              try {
+                opts.onPermissionRejected({
+                  id: permissionId ?? "unknown",
+                  type: permissionType,
+                  title: permissionTitle
+                });
+              } catch {
+              }
+            }
+            if (type === "permission.updated" && permissionId) {
+              (async () => {
+                try {
+                  await client.postSessionIdPermissionsPermissionId({
+                    path: { id: opts.sessionId, permissionID: permissionId },
+                    body: { response: "reject" }
+                  });
+                } catch {
+                }
+              })();
+              continue;
+            }
+            if (type === "question.asked") {
+              if (opts.serverUrl && permissionId) {
+                (async () => {
+                  try {
+                    await fetch(`${opts.serverUrl}/question/${permissionId}/reject`, {
+                      method: "POST"
+                    });
+                  } catch {
+                  }
+                })();
+              }
+              settle({
+                kind: "question_rejected",
+                title: permissionTitle
+              });
+              break;
+            }
+          }
+          if (eventSessionId !== opts.sessionId) continue;
+          resetStall();
+          if (type === "session.idle") {
+            settle({ kind: "idle" });
+            break;
+          }
+          if (type === "session.error") {
+            const msg = props["message"] ?? "session error";
+            sseLog(`[ERROR] session.error: ${msg} props=${JSON.stringify(props)}`);
+            settle({ kind: "error", message: msg });
+            break;
+          }
+        }
+      } catch (err) {
+        if (!settled) {
+          settle({ kind: "error", message: err instanceof Error ? err.message : String(err) });
+        }
+      }
+    })();
+  });
+}
+async function getSessionCost(client, sessionId) {
+  const stats = await getSessionStats(client, sessionId);
+  return stats.cost;
+}
+async function getSessionStats(client, sessionId) {
+  try {
+    const result = await client.session.messages({ path: { id: sessionId } });
+    if (!result.data) {
+      return { cost: 0, tokensIn: 0, tokensOut: 0 };
+    }
+    const messages = result.data;
+    let cost = 0;
+    let tokensIn = 0;
+    let tokensOut = 0;
+    for (const m of messages) {
+      if (m.info.role === "assistant") {
+        if (typeof m.info.cost === "number") cost += m.info.cost;
+        if (m.info.tokens) {
+          tokensIn += m.info.tokens.input ?? 0;
+          tokensOut += m.info.tokens.output ?? 0;
+        }
+      }
+    }
+    return { cost, tokensIn, tokensOut };
+  } catch {
+    return { cost: 0, tokensIn: 0, tokensOut: 0 };
+  }
+}
+async function getLastAssistantMessage(client, sessionId) {
+  try {
+    const result = await client.session.messages({ path: { id: sessionId } });
+    if (!result.data) return "";
+    const messages = result.data;
+    const assistantMessages = messages.filter((m) => m.info.role === "assistant");
+    if (assistantMessages.length === 0) return "";
+    const last = assistantMessages[assistantMessages.length - 1];
+    if (!last) return "";
+    return last.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text).join("");
+  } catch {
+    return "";
+  }
+}
+
+// src/server-error-extractor.ts
+import { readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var OPENCODE_LOG_DIR = join(homedir(), ".local", "share", "opencode", "log");
+function extractServerError() {
+  try {
+    const entries = readdirSync(OPENCODE_LOG_DIR).filter((f) => f.endsWith(".log")).sort().reverse();
+    if (entries.length === 0) return null;
+    const logPath = join(OPENCODE_LOG_DIR, entries[0]);
+    const content = readFileSync(logPath, "utf-8");
+    const lines = content.split("\n").reverse();
+    for (const line of lines) {
+      if (line.includes("service=session.processor") && line.includes("error=")) {
+        const match = line.match(/error=(.+?)(?:\s+stack=|$)/);
+        if (match) return match[1].trim();
+      }
+      if (line.includes("service=llm") && line.includes("error=")) {
+        if (line.includes('error={"error":{}}')) continue;
+        const match = line.match(/error=(.+?)(?:\s+stream|$)/);
+        if (match) return match[1].trim();
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function enhanceSessionError(genericMessage) {
+  if (genericMessage !== "session error" && genericMessage.length > 20) {
+    return genericMessage;
+  }
+  const detail = extractServerError();
+  if (detail) return detail;
+  return genericMessage;
+}
+
+// src/opencode-adapter-class.ts
+var OpenCodeHandle = class {
+  id;
+  server;
+  cwd;
+  constructor(server, cwd) {
+    this.server = server;
+    this.cwd = cwd;
+    this.id = server.url;
+  }
+};
+var OpenCodeAdapter = class {
+  name = "opencode";
+  async start(opts) {
+    const server = await startServer({ cwd: opts.cwd, agentOverrides: opts.agents });
+    return new OpenCodeHandle(server, opts.cwd);
+  }
+  async createSession(handle, opts) {
+    const h = handle;
+    return createSession(h.server.client, {
+      cwd: h.cwd,
+      agentName: opts.agentName
+    });
+  }
+  async sendAndWait(handle, opts) {
+    const h = handle;
+    const result = await sendAndWait(h.server.client, {
+      sessionId: opts.sessionId,
+      message: opts.message,
+      stallMs: opts.stallMs,
+      abortSignal: opts.abortSignal,
+      onToolCall: opts.onToolCall,
+      onTextDelta: opts.onTextDelta,
+      onCostUpdate: opts.onCostUpdate,
+      autoRejectPermissions: true,
+      serverUrl: h.server.url
+    });
+    return result;
+  }
+  async getLastResponse(handle, sessionId) {
+    const h = handle;
+    return getLastAssistantMessage(h.server.client, sessionId);
+  }
+  async getSessionCost(handle, sessionId) {
+    const h = handle;
+    return getSessionCost(h.server.client, sessionId);
+  }
+  async getSessionStats(handle, sessionId) {
+    const h = handle;
+    return getSessionStats(h.server.client, sessionId);
+  }
+  async shutdown(handle) {
+    const h = handle;
+    await h.server.shutdown();
+  }
+  async enhanceError(message) {
+    return enhanceSessionError(message);
+  }
+};
+export {
+  DEFAULT_STARTUP_TIMEOUT_MS,
+  OpenCodeAdapter,
+  createSession,
+  enhanceSessionError,
+  execFileP,
+  extractServerError,
+  getLastAssistantMessage,
+  getSessionCost,
+  getSessionStats,
+  selfTest,
+  sendAndWait,
+  startServer,
+  waitForIdle
+};

package/dist/node_modules/@glrs-dev/adapter-opencode/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@glrs-dev/adapter-opencode",
+  "version": "0.1.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts"
+}

package/dist/node_modules/@glrs-dev/autopilot/dist/auto-ship-EVLBKHUZ.js

@@ -0,0 +1,7 @@
+import {
+  autoShip
+} from "./chunk-BLEIZHET.js";
+import "./chunk-GXXCEGDD.js";
+export {
+  autoShip
+};

package/dist/node_modules/@glrs-dev/autopilot/dist/changeset-generator-HAHYSSUR.js

@@ -0,0 +1,15 @@
+import {
+  generateChangeset,
+  inferBumpLevel,
+  readPlanGoal,
+  readPlanTitle,
+  slugifyTitle
+} from "./chunk-AWRK6S6G.js";
+import "./chunk-GXXCEGDD.js";
+export {
+  generateChangeset,
+  inferBumpLevel,
+  readPlanGoal,
+  readPlanTitle,
+  slugifyTitle
+};