@glrs-dev/cli 2.1.0 → 2.3.0

package/dist/vendor/harness-opencode/dist/chunk-GCWHRUOK.js

@@ -0,0 +1,259 @@
+// src/lib/opencode-server.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import {
+  createOpencodeServer,
+  createOpencodeClient
+} 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 server = await createOpencodeServer({
+    port,
+    timeout: timeoutMs,
+    hostname: "127.0.0.1"
+  });
+  const client = createOpencodeClient({ baseUrl: server.url });
+  let shutdownCalled = false;
+  const shutdown = async () => {
+    if (shutdownCalled) return;
+    shutdownCalled = true;
+    try {
+      await server.close();
+    } catch {
+    }
+  };
+  return { url: server.url, client, shutdown };
+}
+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();
+  return new Promise((resolve) => {
+    let stallTimer = null;
+    let settled = false;
+    const settle = (result) => {
+      if (settled) return;
+      settled = true;
+      if (stallTimer) clearTimeout(stallTimer);
+      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();
+    (async () => {
+      try {
+        for await (const event of sse.stream) {
+          if (settled) break;
+          const ev = event;
+          const props = ev.properties ?? {};
+          const type = ev.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") {
+            const part = props["part"];
+            if (part && part.type === "tool" && part.sessionID === opts.sessionId && part.state?.status === "completed" && part.callID && !reportedToolCalls.has(part.callID)) {
+              reportedToolCalls.add(part.callID);
+              resetStall();
+              try {
+                opts.onToolCall(part.tool ?? "unknown");
+              } 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";
+            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) {
+  try {
+    const result = await client.session.messages({ path: { id: sessionId } });
+    if (!result.data) return 0;
+    const messages = result.data;
+    let total = 0;
+    for (const m of messages) {
+      if (m.info.role === "assistant" && typeof m.info.cost === "number") {
+        total += m.info.cost;
+      }
+    }
+    return total;
+  } catch {
+    return 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 "";
+  }
+}
+
+export {
+  execFileP,
+  DEFAULT_STARTUP_TIMEOUT_MS,
+  startServer,
+  selfTest,
+  createSession,
+  sendAndWait,
+  waitForIdle,
+  getSessionCost,
+  getLastAssistantMessage
+};

package/dist/vendor/harness-opencode/dist/chunk-MJSMBY2Y.js

@@ -0,0 +1,87 @@
+// src/autopilot/plan-parser.ts
+import * as fs from "fs";
+import * as path from "path";
+var DEGRADED = {
+  type: "single",
+  totalItems: 0,
+  checkedItems: 0,
+  phaseCount: 0,
+  phasesCompleted: 0,
+  phases: []
+};
+function countCheckboxes(content) {
+  let total = 0;
+  let checked = 0;
+  const checkboxRe = /^[ \t]*-\s+\[([ xX])\]/gm;
+  let match;
+  while ((match = checkboxRe.exec(content)) !== null) {
+    total++;
+    if (match[1] !== " ") {
+      checked++;
+    }
+  }
+  return { total, checked };
+}
+function parseSingleFile(filePath) {
+  const content = fs.readFileSync(filePath, "utf8");
+  return countCheckboxes(content);
+}
+function detectPhaseFiles(dir) {
+  const entries = fs.readdirSync(dir);
+  return entries.filter((f) => /^phase_\d+\.md$/.test(f)).sort((a, b) => {
+    const na = parseInt(a.replace(/[^0-9]/g, ""), 10);
+    const nb = parseInt(b.replace(/[^0-9]/g, ""), 10);
+    return na - nb;
+  });
+}
+function parseMultiFile(dir) {
+  const mainPath = path.join(dir, "main.md");
+  const mainContent = fs.readFileSync(mainPath, "utf8");
+  const mainCounts = countCheckboxes(mainContent);
+  const phaseFiles = detectPhaseFiles(dir);
+  const phases = [];
+  let phasesCompleted = 0;
+  for (const phaseFile of phaseFiles) {
+    const phasePath = path.join(dir, phaseFile);
+    const { total, checked } = parseSingleFile(phasePath);
+    phases.push({ file: phaseFile, totalItems: total, checkedItems: checked });
+    if (total > 0 && checked === total) {
+      phasesCompleted++;
+    }
+  }
+  return {
+    type: "multi",
+    totalItems: mainCounts.total,
+    checkedItems: mainCounts.checked,
+    phaseCount: phaseFiles.length,
+    phasesCompleted,
+    phases
+  };
+}
+function parsePlanState(planPath) {
+  try {
+    const stat = fs.statSync(planPath);
+    if (stat.isDirectory()) {
+      const mainPath = path.join(planPath, "main.md");
+      if (fs.existsSync(mainPath)) {
+        return parseMultiFile(planPath);
+      }
+      return { ...DEGRADED, type: "multi" };
+    }
+    const { total, checked } = parseSingleFile(planPath);
+    return {
+      type: "single",
+      totalItems: total,
+      checkedItems: checked,
+      phaseCount: 0,
+      phasesCompleted: 0,
+      phases: []
+    };
+  } catch {
+    return { ...DEGRADED };
+  }
+}
+
+export {
+  parsePlanState
+};