@proagentstore/cli 0.4.19 → 0.4.21

package/dist/browser-runner/coding/inspect.js

@@ -97,6 +97,24 @@ export function runRepoGit(workDir, cmd, opts = {}) {
     const truncated = out.length > cap;
     return { cmd, output: truncated ? out.slice(0, cap) : out, truncated };
 }
+/** Read the repo's `origin` remote URL — used to auto-associate a local checkout with its
+ *  GitHub repo (so build status can query Actions). Fixed argv, no shell, no user input;
+ *  returns null when it's not a git repo or has no `origin` remote. */
+export function readGitRemoteOrigin(workDir) {
+    if (!existsSync(resolve(workDir, ".git")))
+        return null;
+    try {
+        const out = execFileSync("git", ["config", "--get", "remote.origin.url"], {
+            cwd: workDir,
+            encoding: "utf-8",
+            timeout: 10_000,
+        });
+        return out.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
 const IGNORE_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", ".turbo", "coverage", ".wrangler"]);
 /** Bounded recursive file tree (names/type/size only — no contents). */
 export function repoTree(workDir, relPath = ".", maxDepth = 3, maxEntries = 500) {

package/dist/browser-runner/coding/runtime.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { defaultStatePath, HeadlessSession } from "./headless.js";
-import { InspectError, readRepoFile, repoTree, runRepoGit } from "./inspect.js";
+import { InspectError, readGitRemoteOrigin, readRepoFile, repoTree, runRepoGit } from "./inspect.js";
 import { ensureRepo, sanitizeSessionName } from "./tmux.js";
 /** Hard cap on a pane returned to the brain/console (matches the worker MAX_PANE_CHARS). */
 const MAX_PANE = 64 * 1024;
@@ -53,6 +53,11 @@ export class CodingRuntime {
     tree(input) {
         return repoTree(this.resolveWorkDir(input), input.path, input.maxDepth, input.maxEntries);
     }
+    /** Read the local checkout's `origin` remote URL — lets PAGS auto-associate a
+     *  local-path repo with its GitHub owner/repo (so build status can query Actions). */
+    gitRemote(input) {
+        return { remote: readGitRemoteOrigin(this.resolveWorkDir(input)) };
+    }
     static taskTypes() {
         return ["coding.session"];
     }

package/dist/browser-runner/coding/tmux.js

@@ -72,6 +72,47 @@ export function listSessions() {
         return [];
     }
 }
+/**
+ * Rich listing of every live session with the signal a UI/agent needs to tell them
+ * apart: window count, attach state, and what's running in the active pane. Returns
+ * an empty array when no tmux server is running (never throws).
+ */
+export function listSessionsDetailed() {
+    try {
+        // Tab-separated so a session name containing spaces can't split a field.
+        const fmt = "#{session_name}\t#{session_windows}\t#{session_attached}\t#{pane_current_command}\t#{window_name}\t#{session_created}";
+        const out = execFileSync("tmux", ["list-sessions", "-F", fmt], { encoding: "utf8", stdio: "pipe" });
+        return out
+            .split("\n")
+            .map((l) => l.trim())
+            .filter(Boolean)
+            .map((line) => {
+            const [name, windows, attached, activeCommand, activeWindow, created] = line.split("\t");
+            return {
+                name: name ?? "",
+                windows: Number(windows) || 0,
+                attached: attached === "1",
+                activeCommand: activeCommand ?? "",
+                activeWindow: activeWindow ?? "",
+                created: created ?? "",
+            };
+        })
+            .filter((s) => s.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Type a command line into a session's active pane and press Enter — the convenience
+ * wrapper over sendText + sendKey for "run this shell/git command". The text is sent
+ * literally (`-l`), so it is never shell-interpreted by tmux; the receiving pane's
+ * shell/CLI runs it exactly as a human would have typed it.
+ */
+export function runCommand(target, command) {
+    sendText(target, command);
+    sendKey(target, "Enter");
+}
 // biome-ignore lint/suspicious/noControlCharactersInRegex: matching ANSI escape codes from tmux output.
 const ANSI = /\x1B\[[0-?]*[ -/]*[@-~]/g;
 /** Strip ANSI escape codes. */

package/dist/browser-runner/runner.js

@@ -25,6 +25,7 @@ const CAPABILITIES = [
     "file.upload",
     "human.approval",
     "human.takeover",
+    "tmux.control",
 ];
 /** How many times a task may attempt an action before handing off to a human. */
 export const MAX_AUTONOMOUS_ATTEMPTS = 3;

package/dist/browser-runner/server.js

@@ -242,6 +242,15 @@ async function route(runner, req, res) {
             return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
         }
     }
+    if (req.method === "POST" && path === "/coding/git-remote") {
+        const b = await readJson(req);
+        try {
+            return json(res, 200, runner.coding.gitRemote(b));
+        }
+        catch (e) {
+            return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
+        }
+    }
     if (req.method === "POST" && path === "/coding/tree") {
         const b = await readJson(req);
         try {
@@ -282,6 +291,72 @@ async function route(runner, req, res) {
     if (req.method === "POST" && codingEndMatch) {
         return json(res, 200, runner.coding.endTakeover(codingEndMatch[1]));
     }
+    // ── tmux connector ──────────────────────────────────────────────────────
+    // The machine-global terminal surface any permitted agent can drive over the
+    // relay: list EVERY live session (not just pags-* ones), read a pane, and —
+    // gated by write-consent in the cloud — send keys / run a command. Reuses the
+    // coding runtime's tmux primitives.
+    if ((req.method === "GET" || req.method === "POST") && path === "/tmux/list") {
+        const { listSessionsDetailed } = await import("./coding/tmux.js");
+        return json(res, 200, { sessions: listSessionsDetailed() });
+    }
+    if (req.method === "POST" && path === "/tmux/capture") {
+        const { capturePane, sessionExists } = await import("./coding/tmux.js");
+        const b = await readJson(req);
+        const session = String(b.session || "").trim();
+        if (!session)
+            return json(res, 400, { error: "A `session` name is required." });
+        if (!sessionExists(session))
+            return json(res, 404, { error: `No tmux session "${session}".` });
+        const lines = Math.min(Math.max(Number(b.lines) || 200, 1), 2000);
+        return json(res, 200, { session, pane: capturePane(session, lines) });
+    }
+    if (req.method === "POST" && path === "/tmux/send") {
+        const { sendText, sendKey, capturePane, sessionExists } = await import("./coding/tmux.js");
+        const b = await readJson(req);
+        const session = String(b.session || "").trim();
+        if (!session)
+            return json(res, 400, { error: "A `session` name is required." });
+        if (!sessionExists(session))
+            return json(res, 404, { error: `No tmux session "${session}".` });
+        if (b.text != null)
+            sendText(session, String(b.text));
+        for (const k of b.keys ?? [])
+            sendKey(session, String(k));
+        return json(res, 200, { session, pane: capturePane(session, 200) });
+    }
+    if (req.method === "POST" && path === "/tmux/run") {
+        const { runCommand, capturePane, sessionExists } = await import("./coding/tmux.js");
+        const b = await readJson(req);
+        const session = String(b.session || "").trim();
+        const command = String(b.command ?? "");
+        if (!session)
+            return json(res, 400, { error: "A `session` name is required." });
+        if (!command.trim())
+            return json(res, 400, { error: "A `command` is required." });
+        if (!sessionExists(session))
+            return json(res, 404, { error: `No tmux session "${session}".` });
+        runCommand(session, command);
+        return json(res, 200, { session, command, pane: capturePane(session, 200) });
+    }
+    if (req.method === "POST" && path === "/tmux/session") {
+        const { createSession, killSession, sessionExists } = await import("./coding/tmux.js");
+        const { homedir } = await import("node:os");
+        const b = await readJson(req);
+        const session = String(b.session || "").trim();
+        if (!session)
+            return json(res, 400, { error: "A `session` name is required." });
+        if (b.action === "kill") {
+            return json(res, 200, { session, killed: killSession(session) });
+        }
+        // default: create
+        if (sessionExists(session))
+            return json(res, 200, { session, created: false, existed: true });
+        const { resolve } = await import("node:path");
+        const workDir = resolve(String(b.workDir || "~").replace(/^~(?=$|\/)/, homedir()));
+        createSession(session, workDir, b.command ? String(b.command) : undefined);
+        return json(res, 200, { session, created: true, workDir });
+    }
     return json(res, 404, { error: "Not found" });
 }
 function authorize(req, config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.19",
+  "version": "0.4.21",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",