@glrs-dev/cli 0.1.1 → 1.0.0

package/dist/vendor/harness-opencode/dist/index.js

@@ -3,7 +3,7 @@ import {
   createAgents,
   formatModelOverrideWarning,
   validateModelOverride
-} from "./chunk-XCZ3NOXR.js";
+} from "./chunk-CZMAJISX.js";
 import {
   PACKAGE_NAME,
   readOurPackageVersion,
@@ -1850,7 +1850,7 @@ import { join as join8 } from "path";
 var APP_KEY = "A-US-3617699429";
 var ENDPOINT = "https://us.aptabase.com/api/v0/event";
 var PKG_NAME = "@glrs-dev/harness-plugin-opencode";
-var PKG_VERSION = true ? "0.2.0" : "dev";
+var PKG_VERSION = true ? "1.0.0" : "dev";
 var DISABLED = process.env.HARNESS_OPENCODE_TELEMETRY === "0" || process.env.HARNESS_OPENCODE_TELEMETRY === "false" || process.env.DO_NOT_TRACK === "1" || process.env.CI === "true";
 var SESSION_ID = randomUUID();
 function getInstallId() {

package/dist/vendor/harness-opencode/dist/install-X5KEANRB.js

@@ -0,0 +1,13 @@
+import {
+  MODEL_PRESETS,
+  install,
+  writeMcpToggles,
+  writePluginOption
+} from "./chunk-WBBN7OVN.js";
+import "./chunk-VJUETC6A.js";
+export {
+  MODEL_PRESETS,
+  install,
+  writeMcpToggles,
+  writePluginOption
+};

package/dist/vendor/harness-opencode/dist/paths-LT3QQKCF.js

@@ -0,0 +1,18 @@
+import {
+  getPilotDir,
+  getPlansDir,
+  getRunDir,
+  getStateDbPath,
+  getTaskJsonlPath,
+  getWorkerJsonlPath,
+  resolveBaseDir
+} from "./chunk-BKTFWXLG.js";
+export {
+  getPilotDir,
+  getPlansDir,
+  getRunDir,
+  getStateDbPath,
+  getTaskJsonlPath,
+  getWorkerJsonlPath,
+  resolveBaseDir
+};

package/dist/vendor/harness-opencode/dist/pilot/mcp/status-server.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/vendor/harness-opencode/dist/pilot/mcp/status-server.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import {
+  readSessions
+} from "../../chunk-RNRCXQ65.js";
+
+// src/pilot/mcp/status-server.ts
+import * as path from "path";
+import { Database } from "bun:sqlite";
+
+// src/pilot/mcp/throttle.ts
+function canEmit(key, now, lastEmittedAt, minIntervalMs = 6e4) {
+  const mapKey = `${key.runId}|${key.taskId}`;
+  const last = lastEmittedAt.get(mapKey);
+  if (last === void 0) {
+    return { ok: true };
+  }
+  const elapsed = now - last;
+  if (elapsed >= minIntervalMs) {
+    return { ok: true };
+  }
+  return { ok: false, retryInMs: minIntervalMs - elapsed };
+}
+function recordEmission(key, now, lastEmittedAt) {
+  const mapKey = `${key.runId}|${key.taskId}`;
+  lastEmittedAt.set(mapKey, now);
+}
+
+// src/pilot/mcp/status-server.ts
+var SESSIONS_PATH = process.env.PILOT_SESSIONS_PATH;
+var STATE_DB_PATH = process.env.PILOT_STATE_DB_PATH;
+var RUN_ID = process.env.PILOT_RUN_ID;
+var throttleState = /* @__PURE__ */ new Map();
+var MIN_INTERVAL_MS = 6e4;
+var MAX_MESSAGE_LENGTH = 200;
+if (!SESSIONS_PATH || !STATE_DB_PATH || !RUN_ID) {
+  console.error(
+    "Missing required environment variables: PILOT_SESSIONS_PATH, PILOT_STATE_DB_PATH, PILOT_RUN_ID"
+  );
+  process.exit(1);
+}
+function sendResponse(resp) {
+  process.stdout.write(JSON.stringify(resp) + "\n");
+}
+function sendError(id, code, message, data) {
+  sendResponse({
+    jsonrpc: "2.0",
+    id,
+    error: { code, message, data }
+  });
+}
+function sendResult(id, result) {
+  sendResponse({
+    jsonrpc: "2.0",
+    id,
+    result
+  });
+}
+function handleStatusUpdate(requestId, params) {
+  const sessionId = params._meta?.sessionId;
+  const message = params.arguments?.message;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    sendError(requestId, -32602, "Invalid params: missing or invalid sessionId in _meta");
+    return;
+  }
+  if (typeof message !== "string" || message.length === 0) {
+    sendError(requestId, -32602, "Invalid params: message must be a non-empty string");
+    return;
+  }
+  if (message.length > MAX_MESSAGE_LENGTH) {
+    sendError(
+      requestId,
+      -32602,
+      `Invalid params: message exceeds ${MAX_MESSAGE_LENGTH} characters`
+    );
+    return;
+  }
+  const runDir = path.dirname(SESSIONS_PATH);
+  const registry = readSessions(runDir);
+  const session = registry[sessionId];
+  if (!session) {
+    sendError(
+      requestId,
+      -32e3,
+      "Unknown session: session not found in registry",
+      { sessionId }
+    );
+    return;
+  }
+  if (session.runId !== RUN_ID) {
+    sendError(
+      requestId,
+      -32e3,
+      "Session belongs to a different run",
+      { sessionId, expectedRunId: RUN_ID, actualRunId: session.runId }
+    );
+    return;
+  }
+  const now = Date.now();
+  const throttleKey = { runId: session.runId, taskId: session.taskId };
+  const throttleResult = canEmit(throttleKey, now, throttleState, MIN_INTERVAL_MS);
+  if (!throttleResult.ok) {
+    sendResult(requestId, {
+      success: false,
+      throttled: true,
+      retryInMs: throttleResult.retryInMs,
+      message: `Throttled: try again in ${Math.ceil(throttleResult.retryInMs / 1e3)}s`
+    });
+    return;
+  }
+  try {
+    const db = new Database(STATE_DB_PATH, { readwrite: true });
+    try {
+      const ts = now;
+      const payload = { message, sessionId };
+      db.run(
+        `INSERT INTO events (run_id, task_id, ts, kind, payload) VALUES (?, ?, ?, ?, ?)`,
+        [session.runId, session.taskId, ts, "task.progress", JSON.stringify(payload)]
+      );
+    } finally {
+      db.close();
+    }
+    recordEmission(throttleKey, now, throttleState);
+    sendResult(requestId, {
+      success: true,
+      throttled: false,
+      taskId: session.taskId
+    });
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    sendError(
+      requestId,
+      -32e3,
+      `Failed to write event: ${errorMessage}`,
+      { sessionId, taskId: session.taskId }
+    );
+  }
+}
+var TOOLS_LIST = {
+  tools: [
+    {
+      name: "provide_status_update",
+      description: "Emit a one-sentence progress update for the current task. Use this to inform the user what you're working on during long-running operations. Keep messages under 200 characters. Rate limited to once per 60 seconds.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          message: {
+            type: "string",
+            description: "A one-sentence description of current progress (max 200 chars)"
+          }
+        },
+        required: ["message"]
+      }
+    }
+  ]
+};
+function handleRequest(req) {
+  switch (req.method) {
+    case "initialize": {
+      sendResult(req.id, {
+        protocolVersion: "2024-11-05",
+        capabilities: {},
+        serverInfo: {
+          name: "pilot-status-server",
+          version: "0.1.0"
+        }
+      });
+      break;
+    }
+    case "tools/list": {
+      sendResult(req.id, TOOLS_LIST);
+      break;
+    }
+    case "tools/call": {
+      const params = req.params;
+      if (!params || typeof params.name !== "string") {
+        sendError(req.id, -32602, "Invalid params: expected { name: string, arguments?: object }");
+        return;
+      }
+      if (params.name === "provide_status_update") {
+        handleStatusUpdate(req.id, params);
+      } else {
+        sendError(req.id, -32601, `Unknown tool: ${params.name}`);
+      }
+      break;
+    }
+    default: {
+      sendError(req.id, -32601, `Method not found: ${req.method}`);
+    }
+  }
+}
+var buffer = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  buffer += chunk;
+  let newlineIndex;
+  while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+    const line = buffer.slice(0, newlineIndex).trim();
+    buffer = buffer.slice(newlineIndex + 1);
+    if (line.length === 0) continue;
+    try {
+      const req = JSON.parse(line);
+      if (req.jsonrpc !== "2.0") {
+        sendError(req.id ?? null, -32600, "Invalid Request: jsonrpc must be '2.0'");
+        continue;
+      }
+      handleRequest(req);
+    } catch {
+      sendError(null, -32700, "Parse error: invalid JSON");
+    }
+  }
+});
+process.stdin.on("end", () => {
+  if (buffer.trim().length > 0) {
+    try {
+      const req = JSON.parse(buffer.trim());
+      if (req.jsonrpc === "2.0") {
+        handleRequest(req);
+      }
+    } catch {
+      sendError(null, -32700, "Parse error: invalid JSON");
+    }
+  }
+  process.exit(0);
+});
+process.stdin.on("error", (err) => {
+  console.error("stdin error:", err);
+  process.exit(1);
+});

package/dist/vendor/harness-opencode/dist/pilot-config-7LJZ23YK.js

@@ -0,0 +1,55 @@
+// src/pilot/worker/pilot-config.ts
+import { promises as fs } from "fs";
+import * as path from "path";
+var PILOT_JSON_FILENAME = ".glrs/pilot.json";
+var EMPTY_CONFIG = {
+  baseline: [],
+  after_each: []
+};
+async function loadPilotConfig(cwd) {
+  const filePath = path.join(cwd, PILOT_JSON_FILENAME);
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf8");
+  } catch {
+    return EMPTY_CONFIG;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `${PILOT_JSON_FILENAME}: invalid JSON \u2014 ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(
+      `${PILOT_JSON_FILENAME}: expected a JSON object, got ${typeof parsed}`
+    );
+  }
+  const obj = parsed;
+  const baseline = parseStringArray(obj, "baseline");
+  const after_each = parseStringArray(obj, "after_each");
+  return { baseline, after_each };
+}
+function parseStringArray(obj, key) {
+  const val = obj[key];
+  if (val === void 0 || val === null) return [];
+  if (!Array.isArray(val)) {
+    throw new Error(
+      `${PILOT_JSON_FILENAME}: "${key}" must be an array of strings, got ${typeof val}`
+    );
+  }
+  for (let i = 0; i < val.length; i++) {
+    if (typeof val[i] !== "string" || val[i].length === 0) {
+      throw new Error(
+        `${PILOT_JSON_FILENAME}: "${key}[${i}]" must be a non-empty string`
+      );
+    }
+  }
+  return val;
+}
+export {
+  PILOT_JSON_FILENAME,
+  loadPilotConfig
+};

package/dist/vendor/harness-opencode/dist/runs-QWPL3TKV.js

@@ -0,0 +1,18 @@
+import {
+  createRun,
+  getRun,
+  latestRun,
+  listRuns,
+  markRunFinished,
+  markRunResumed,
+  markRunRunning
+} from "./chunk-5TAMY7P6.js";
+export {
+  createRun,
+  getRun,
+  latestRun,
+  listRuns,
+  markRunFinished,
+  markRunResumed,
+  markRunRunning
+};

package/dist/vendor/harness-opencode/dist/safety-gate-WM3EWOCY.js

@@ -0,0 +1,10 @@
+import {
+  SAFETY_GATE_TOLERATE,
+  checkCwdSafety,
+  headSha
+} from "./chunk-KB7M7JXU.js";
+export {
+  SAFETY_GATE_TOLERATE,
+  checkCwdSafety,
+  headSha
+};

package/dist/vendor/harness-opencode/dist/setup-hook-FHTXMAQL.js

@@ -0,0 +1,88 @@
+// src/pilot/worker/setup-hook.ts
+import { spawn } from "child_process";
+import { promises as fs } from "fs";
+import * as path from "path";
+var SETUP_HOOK_RELATIVE_PATH = ".glrs/hooks/pilot_setup";
+var SETUP_HOOK_TIMEOUT_MS = 10 * 60 * 1e3;
+async function runSetupHook(args) {
+  const hookPath = path.join(args.cwd, SETUP_HOOK_RELATIVE_PATH);
+  const onLine = args.onLine ?? ((chunk) => void process.stderr.write(chunk));
+  const timeoutMs = args.timeoutMs ?? SETUP_HOOK_TIMEOUT_MS;
+  let stat;
+  try {
+    stat = await fs.stat(hookPath);
+  } catch {
+    return { kind: "skipped" };
+  }
+  if (process.platform !== "win32") {
+    const mode = stat.mode;
+    const executable = (mode & 73) !== 0;
+    if (!executable) {
+      return { kind: "not-executable", hookPath };
+    }
+  }
+  const start = Date.now();
+  return await new Promise((resolve) => {
+    const child = spawn(hookPath, [], {
+      cwd: args.cwd,
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 500);
+    }, timeoutMs);
+    child.stdout?.on("data", (buf) => onLine(buf.toString()));
+    child.stderr?.on("data", (buf) => onLine(buf.toString()));
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        kind: "spawn-error",
+        hookPath,
+        error: err.message
+      });
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      const durationMs = Date.now() - start;
+      if (timedOut) {
+        resolve({ kind: "timed-out", hookPath, timeoutMs });
+        return;
+      }
+      if (signal !== null && signal !== void 0) {
+        resolve({
+          kind: "failed",
+          hookPath,
+          exitCode: -1,
+          durationMs
+        });
+        return;
+      }
+      if (code !== 0) {
+        resolve({
+          kind: "failed",
+          hookPath,
+          exitCode: code ?? -1,
+          durationMs
+        });
+        return;
+      }
+      resolve({ kind: "ok", durationMs });
+    });
+  });
+}
+export {
+  SETUP_HOOK_RELATIVE_PATH,
+  SETUP_HOOK_TIMEOUT_MS,
+  runSetupHook
+};