@pome-sh/cli 0.20.0 → 0.21.1

package/README.md

@@ -102,10 +102,12 @@ The package publishes the `pome` binary from `dist/src/cli/main.js`.
 
 ### Versioning — every behavior change ships with a bump
 
-Any PR that touches `cli/src/**` must either add a changeset under
-`cli/.changeset/` or bump `cli/package.json` directly; CI enforces this
-via [`scripts/check-cli-version-bump.sh`](../scripts/check-cli-version-bump.sh).
-Preferred path: `cd cli && npm run changeset`.
+Bump `version` in `cli/package.json` and add the user-facing entry to
+`CHANGELOG.md` in the same PR. Merging to `main` is the release trigger:
+`.github/workflows/release.yml` compares the local version against npm and
+publishes when they differ. `pome --version` reports the bumped value from a
+build-time constant, so a user can always tell whether their install carries a
+given fix.
 
 ## License
 

package/dist/agent-Q2UTRJYL.js

@@ -0,0 +1,408 @@
+import { DemoCapacityError, capacityMarkerLine, capacityKindFrom, capacityLabel } from './chunk-ZX4WNSZ5.js';
+import { z } from 'zod';
+import { request } from 'node:http';
+import { connect as connect$1 } from 'node:net';
+import { connect } from 'node:tls';
+
+function isLoopbackHost(host) {
+  const value = host.trim().toLowerCase();
+  if (value === "localhost" || value.endsWith(".localhost")) return true;
+  if (value === "::1" || value === "[::1]") return true;
+  return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(value);
+}
+function matchesNoProxy(host, noProxy) {
+  if (!noProxy) return false;
+  const candidate = host.trim().toLowerCase();
+  return noProxy.split(",").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0).some(
+    (entry) => entry === "*" || candidate === entry || candidate.endsWith(entry.startsWith(".") ? entry : `.${entry}`)
+  );
+}
+async function postJsonMaybeViaProxy(options) {
+  const target = new URL(options.url);
+  const useProxy = Boolean(options.proxyUrl) && (options.forceProxy === true || !isLoopbackHost(target.hostname) && !matchesNoProxy(target.hostname, options.noProxy));
+  if (!useProxy) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), options.timeoutMs ?? 6e4);
+    try {
+      const res = await fetch(options.url, {
+        method: "POST",
+        headers: { ...options.headers, "content-type": "application/json" },
+        body: JSON.stringify(options.body),
+        signal: ctrl.signal
+      });
+      return { status: res.status, bodyText: await res.text() };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  return postJsonThroughConnectProxy(target, options);
+}
+async function postJsonThroughConnectProxy(target, options) {
+  const proxy = new URL(options.proxyUrl);
+  const targetPort = Number(target.port || (target.protocol === "https:" ? 443 : 80));
+  const timeoutMs = options.timeoutMs ?? 6e4;
+  const rawSocket = await connectTunnel(
+    proxy.hostname,
+    Number(proxy.port || 80),
+    target.hostname,
+    targetPort,
+    timeoutMs
+  );
+  const socket = target.protocol === "https:" ? await new Promise((resolve, reject) => {
+    const tlsSocket = connect(
+      { socket: rawSocket, servername: target.hostname },
+      () => resolve(tlsSocket)
+    );
+    tlsSocket.once("error", reject);
+  }) : rawSocket;
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify(options.body);
+    const req = request(
+      {
+        createConnection: () => socket,
+        method: "POST",
+        host: target.hostname,
+        port: targetPort,
+        path: `${target.pathname}${target.search}`,
+        headers: {
+          ...options.headers,
+          host: target.host,
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(payload),
+          connection: "close"
+        },
+        timeout: timeoutMs
+      },
+      (res) => {
+        let bodyText = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          bodyText += chunk;
+        });
+        res.on("end", () => {
+          resolve({ status: res.statusCode ?? 0, bodyText });
+        });
+        res.on("error", reject);
+      }
+    );
+    req.on("timeout", () => {
+      req.destroy(new Error(`request to ${target.host} timed out after ${timeoutMs}ms`));
+    });
+    req.on("error", (err) => {
+      socket.destroy();
+      reject(err);
+    });
+    req.end(payload);
+  });
+}
+function connectTunnel(proxyHost, proxyPort, targetHost, targetPort, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const sock = connect$1({ host: proxyHost, port: proxyPort });
+    let buf = "";
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      sock.destroy();
+      reject(new Error(`CONNECT to ${targetHost}:${targetPort} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      sock.destroy();
+      reject(err);
+    };
+    sock.once("error", fail);
+    const onData = (chunk) => {
+      buf += chunk.toString("utf8");
+      const headerEnd = buf.indexOf("\r\n\r\n");
+      if (headerEnd === -1) return;
+      sock.off("data", onData);
+      if (!/^HTTP\/1\.[01] 200/.test(buf)) {
+        fail(new Error(`CONNECT ${targetHost}:${targetPort} refused: ${buf.split("\r\n")[0]}`));
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      sock.pause();
+      const rest = Buffer.from(buf.slice(headerEnd + 4), "utf8");
+      if (rest.length > 0) sock.unshift(rest);
+      sock.resume();
+      resolve(sock);
+    };
+    sock.on("data", onData);
+    sock.write(
+      `CONNECT ${targetHost}:${targetPort} HTTP/1.1\r
+Host: ${targetHost}:${targetPort}\r
+\r
+`
+    );
+  });
+}
+
+// src/demo/gateway.ts
+var gatewayResponseSchema = z.object({
+  text: z.string(),
+  tool_calls: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      input: z.unknown()
+    })
+  ),
+  finish_reason: z.string(),
+  usage: z.object({
+    input_tokens: z.number(),
+    output_tokens: z.number()
+  }).optional()
+});
+var DemoGatewayError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "DemoGatewayError";
+  }
+  status;
+};
+async function callDemoGateway(options) {
+  const { status, bodyText } = await postJsonMaybeViaProxy({
+    url: options.gatewayUrl,
+    headers: { authorization: `Bearer ${options.demoToken}` },
+    body: {
+      task_name: options.taskName,
+      messages: options.messages,
+      ...options.tools && options.tools.length > 0 ? { tools: options.tools } : {}
+    },
+    proxyUrl: options.proxyUrl,
+    noProxy: options.noProxy,
+    timeoutMs: options.timeoutMs ?? 12e4,
+    forceProxy: options.forceProxyForTest
+  });
+  let json = {};
+  try {
+    json = bodyText.length ? JSON.parse(bodyText) : {};
+  } catch {
+    throw new DemoGatewayError(
+      `demo gateway returned non-JSON (status ${status})`,
+      status
+    );
+  }
+  if (status < 200 || status >= 300) {
+    const envelope = json.error;
+    const kind = capacityKindFrom(status, envelope?.details?.kind);
+    if (kind) {
+      throw new DemoCapacityError(kind, envelope?.message ?? capacityLabel(kind));
+    }
+    throw new DemoGatewayError(
+      envelope?.message ?? `demo gateway \u2192 HTTP ${status}`,
+      status
+    );
+  }
+  const parsed = gatewayResponseSchema.safeParse(json);
+  if (!parsed.success) {
+    throw new DemoGatewayError(
+      `demo gateway returned an unexpected shape: ${parsed.error.message}`,
+      status
+    );
+  }
+  return parsed.data;
+}
+
+// src/demo/agent.ts
+var MAX_TURNS = 12;
+var DEMO_AGENT_TOOLS = [
+  {
+    name: "list_open_issues",
+    description: "List the open issues in the repository you are triaging. Returns number, title, body, and current labels for each.",
+    input_schema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "add_label",
+    description: "Apply an EXISTING label to an issue by number. Fails if the label does not exist in the repository.",
+    input_schema: {
+      type: "object",
+      properties: {
+        issue_number: { type: "number", description: "Issue number, e.g. 1" },
+        label: { type: "string", description: "Name of an existing label" }
+      },
+      required: ["issue_number", "label"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "comment_on_issue",
+    description: "Leave one comment on an issue by number.",
+    input_schema: {
+      type: "object",
+      properties: {
+        issue_number: { type: "number", description: "Issue number, e.g. 1" },
+        body: { type: "string", description: "Comment body (markdown)" }
+      },
+      required: ["issue_number", "body"],
+      additionalProperties: false
+    }
+  }
+];
+function readDemoAgentEnv(env) {
+  const required = (name) => {
+    const value = env[name]?.trim();
+    if (!value) throw new Error(`${name} is required for pome demo-agent`);
+    return value;
+  };
+  return {
+    task: required("POME_TASK"),
+    twinRestUrl: required("POME_GITHUB_REST_URL"),
+    twinAuthToken: required("POME_AUTH_TOKEN"),
+    gatewayUrl: required("POME_DEMO_LLM_URL"),
+    demoToken: required("POME_DEMO_TOKEN"),
+    taskName: required("POME_DEMO_TASK_NAME"),
+    repo: required("POME_DEMO_REPO"),
+    proxyUrl: env.HTTPS_PROXY ?? env.HTTP_PROXY,
+    noProxy: env.NO_PROXY
+  };
+}
+async function twinFetch(agentEnv, path, init) {
+  const res = await fetch(`${agentEnv.twinRestUrl}${path}`, {
+    method: init?.method ?? "GET",
+    headers: {
+      authorization: `Bearer ${agentEnv.twinAuthToken}`,
+      ...init?.body !== void 0 ? { "content-type": "application/json" } : {}
+    },
+    body: init?.body !== void 0 ? JSON.stringify(init.body) : void 0
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new Error(
+      `${init?.method ?? "GET"} ${path} \u2192 ${res.status}: ${text.slice(0, 300)}`
+    );
+  }
+  return text.length ? JSON.parse(text) : {};
+}
+async function executeDemoTool(agentEnv, name, input) {
+  const [owner, repo] = agentEnv.repo.split("/");
+  const args = input ?? {};
+  try {
+    switch (name) {
+      case "list_open_issues": {
+        const issues = await twinFetch(
+          agentEnv,
+          `/repos/${owner}/${repo}/issues?state=open`
+        );
+        return {
+          output: issues.map((issue) => ({
+            number: issue.number,
+            title: issue.title,
+            body: issue.body,
+            labels: (issue.labels ?? []).map(
+              (label) => typeof label === "string" ? label : label.name
+            )
+          })),
+          isError: false
+        };
+      }
+      case "add_label": {
+        const issueNumber = Number(args.issue_number);
+        const label = String(args.label ?? "");
+        if (!Number.isInteger(issueNumber) || label.length === 0) {
+          return { output: "add_label requires issue_number and label", isError: true };
+        }
+        await twinFetch(agentEnv, `/repos/${owner}/${repo}/issues/${issueNumber}/labels`, {
+          method: "POST",
+          body: { labels: [label] }
+        });
+        return { output: `applied label "${label}" to issue #${issueNumber}`, isError: false };
+      }
+      case "comment_on_issue": {
+        const issueNumber = Number(args.issue_number);
+        const body = String(args.body ?? "");
+        if (!Number.isInteger(issueNumber) || body.length === 0) {
+          return { output: "comment_on_issue requires issue_number and body", isError: true };
+        }
+        await twinFetch(agentEnv, `/repos/${owner}/${repo}/issues/${issueNumber}/comments`, {
+          method: "POST",
+          body: { body }
+        });
+        return { output: `commented on issue #${issueNumber}`, isError: false };
+      }
+      default:
+        return { output: `unknown tool: ${name}`, isError: true };
+    }
+  } catch (err) {
+    return {
+      output: err instanceof Error ? err.message : String(err),
+      isError: true
+    };
+  }
+}
+async function runDemoAgent(agentEnv, io) {
+  const messages = [{ role: "user", content: agentEnv.task }];
+  try {
+    for (let turn = 0; turn < MAX_TURNS; turn += 1) {
+      const response = await callDemoGateway({
+        gatewayUrl: agentEnv.gatewayUrl,
+        demoToken: agentEnv.demoToken,
+        taskName: agentEnv.taskName,
+        messages,
+        tools: DEMO_AGENT_TOOLS,
+        proxyUrl: agentEnv.proxyUrl,
+        noProxy: agentEnv.noProxy
+      });
+      if (response.tool_calls.length === 0) {
+        io.log(response.text.trim().length > 0 ? response.text.trim() : "(done)");
+        return 0;
+      }
+      const assistantParts = [];
+      if (response.text.trim().length > 0) {
+        assistantParts.push({ type: "text", text: response.text });
+      }
+      for (const call of response.tool_calls) {
+        assistantParts.push({
+          type: "tool-call",
+          toolCallId: call.id,
+          toolName: call.name,
+          input: call.input
+        });
+      }
+      messages.push({ role: "assistant", content: assistantParts });
+      const resultParts = [];
+      for (const call of response.tool_calls) {
+        const result = await executeDemoTool(agentEnv, call.name, call.input);
+        resultParts.push({
+          type: "tool-result",
+          toolCallId: call.id,
+          toolName: call.name,
+          output: result.isError ? { type: "error-text", value: String(result.output) } : { type: "json", value: result.output }
+        });
+      }
+      messages.push({ role: "tool", content: resultParts });
+    }
+    io.error(`demo agent gave up after ${MAX_TURNS} model calls without finishing`);
+    return 1;
+  } catch (err) {
+    if (err instanceof DemoCapacityError) {
+      io.error(capacityMarkerLine(err.kind));
+      io.error(err.message);
+      return 42;
+    }
+    io.error(err instanceof Error ? err.message : String(err));
+    return 1;
+  }
+}
+async function runDemoAgentCommand() {
+  if (process.env.POME_PREFLIGHT === "1") {
+    console.log("preflight ok");
+    return 0;
+  }
+  const agentEnv = readDemoAgentEnv(process.env);
+  return runDemoAgent(agentEnv, {
+    log: (line) => console.log(line),
+    error: (line) => console.error(line)
+  });
+}
+
+export { DEMO_AGENT_TOOLS, executeDemoTool, readDemoAgentEnv, runDemoAgent, runDemoAgentCommand };

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "package": "pome-sh",
-  "version": "0.20.0",
-  "git_sha": "4f64f517734b8b43ebd4bb8968a388e6b089dc62",
-  "build_time": "2026-08-04T21:23:39.046Z"
+  "version": "0.21.1",
+  "git_sha": "40a6f44ac7b048277219ffb7ff5b1db8ac44765e",
+  "build_time": "2026-08-05T16:28:17.637Z"
 }