pwragent 0.0.0 → 1.3.7

package/node_modules/node-pty/src/win/conpty_console_list.cc

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2019, Microsoft Corporation (MIT License).
+ */
+
+#define NODE_ADDON_API_DISABLE_DEPRECATED
+#include <napi.h>
+#include <windows.h>
+
+static Napi::Value ApiConsoleProcessList(const Napi::CallbackInfo& info) {
+  Napi::Env env(info.Env());
+  if (info.Length() != 1 ||
+      !info[0].IsNumber()) {
+    throw Napi::Error::New(env, "Usage: getConsoleProcessList(shellPid)");
+  }
+
+  const DWORD pid = info[0].As<Napi::Number>().Uint32Value();
+
+  if (!FreeConsole()) {
+    throw Napi::Error::New(env, "FreeConsole failed");
+  }
+  if (!AttachConsole(pid)) {
+    throw Napi::Error::New(env, "AttachConsole failed");
+  }
+  auto processList = std::vector<DWORD>(64);
+  auto processCount = GetConsoleProcessList(&processList[0], static_cast<DWORD>(processList.size()));
+  if (processList.size() < processCount) {
+      processList.resize(processCount);
+      processCount = GetConsoleProcessList(&processList[0], static_cast<DWORD>(processList.size()));
+  }
+  FreeConsole();
+
+  Napi::Array result = Napi::Array::New(env);
+  for (DWORD i = 0; i < processCount; i++) {
+    result.Set(i, Napi::Number::New(env, processList[i]));
+  }
+  return result;
+}
+
+Napi::Object init(Napi::Env env, Napi::Object exports) {
+  exports.Set("getConsoleProcessList", Napi::Function::New(env, ApiConsoleProcessList));
+  return exports;
+};
+
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, init);

package/node_modules/node-pty/src/win/path_util.cc

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2013-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+#include <stdexcept>
+#include <Shlwapi.h> // PathCombine
+#include <Windows.h>
+#include "path_util.h"
+
+namespace path_util {
+
+std::wstring to_wstring(const Napi::String& str) {
+  const std::u16string & u16 = str.Utf16Value();
+  return std::wstring(u16.begin(), u16.end());
+}
+
+std::string wstring_to_string(const std::wstring &wide_string) {
+  if (wide_string.empty()) {
+    return "";
+  }
+  const auto size_needed = WideCharToMultiByte(CP_UTF8, 0, &wide_string.at(0), (int)wide_string.size(), nullptr, 0, nullptr, nullptr);
+  if (size_needed <= 0) {
+    return "";
+  }
+  std::string result(size_needed, 0);
+  WideCharToMultiByte(CP_UTF8, 0, &wide_string.at(0), (int)wide_string.size(), &result.at(0), size_needed, nullptr, nullptr);
+  return result;
+}
+
+const char* from_wstring(const wchar_t* wstr) {
+  int bufferSize = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
+  if (bufferSize <= 0) {
+    return "";
+  }
+  char *output = new char[bufferSize];
+  int status = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, output, bufferSize, NULL, NULL);
+  if (status == 0) {
+    return "";
+  }
+  return output;
+}
+
+bool file_exists(std::wstring filename) {
+  DWORD attr = ::GetFileAttributesW(filename.c_str());
+  if (attr == INVALID_FILE_ATTRIBUTES || (attr & FILE_ATTRIBUTE_DIRECTORY)) {
+    return false;
+  }
+  return true;
+}
+
+// cmd.exe -> C:\Windows\system32\cmd.exe
+std::wstring get_shell_path(std::wstring filename) {
+  std::wstring shellpath;
+
+  if (file_exists(filename)) {
+    return shellpath;
+  }
+
+  wchar_t* buffer_ = new wchar_t[MAX_ENV];
+  int read = ::GetEnvironmentVariableW(L"Path", buffer_, MAX_ENV);
+  if (read) {
+    std::wstring delimiter = L";";
+    size_t pos = 0;
+    std::vector<std::wstring> paths;
+    std::wstring buffer(buffer_);
+    while ((pos = buffer.find(delimiter)) != std::wstring::npos) {
+      paths.push_back(buffer.substr(0, pos));
+      buffer.erase(0, pos + delimiter.length());
+    }
+
+    const wchar_t *filename_ = filename.c_str();
+
+    for (size_t i = 0; i < paths.size(); ++i) {
+      std::wstring path = paths[i];
+      wchar_t searchPath[MAX_PATH];
+      ::PathCombineW(searchPath, const_cast<wchar_t*>(path.c_str()), filename_);
+
+      if (searchPath == NULL) {
+        continue;
+      }
+
+      if (file_exists(searchPath)) {
+        shellpath = searchPath;
+        break;
+      }
+    }
+  }
+
+  delete[] buffer_;
+  return shellpath;
+}
+
+}  // namespace path_util

package/node_modules/node-pty/src/win/path_util.h

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2013-2015, Christopher Jeffrey, Peter Sunde (MIT License)
+ * Copyright (c) 2016, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+#ifndef NODE_PTY_PATH_UTIL_H_
+#define NODE_PTY_PATH_UTIL_H_
+
+#define NODE_ADDON_API_DISABLE_DEPRECATED
+#include <napi.h>
+#include <string>
+
+#define MAX_ENV 65536
+
+namespace path_util {
+
+std::wstring to_wstring(const Napi::String& str);
+std::string wstring_to_string(const std::wstring &wide_string);
+const char* from_wstring(const wchar_t* wstr);
+bool file_exists(std::wstring filename);
+std::wstring get_shell_path(std::wstring filename);
+
+}  // namespace path_util
+
+#endif  // NODE_PTY_PATH_UTIL_H_

package/node_modules/node-pty/typings/node-pty.d.ts

@@ -0,0 +1,215 @@
+/**
+ * Copyright (c) 2017, Daniel Imms (MIT License).
+ * Copyright (c) 2018, Microsoft Corporation (MIT License).
+ */
+
+declare module 'node-pty' {
+  /**
+   * Forks a process as a pseudoterminal.
+   * @param file The file to launch.
+   * @param args The file's arguments as argv (string[]) or in a pre-escaped CommandLine format
+   * (string). Note that the CommandLine option is only available on Windows and is expected to be
+   * escaped properly.
+   * @param options The options of the terminal.
+   * @see CommandLineToArgvW https://msdn.microsoft.com/en-us/library/windows/desktop/bb776391(v=vs.85).aspx
+   * @see Parsing C++ Command-Line Arguments https://msdn.microsoft.com/en-us/library/17w5ykft.aspx
+   * @see GetCommandLine https://msdn.microsoft.com/en-us/library/windows/desktop/ms683156.aspx
+   */
+  export function spawn(file: string, args: string[] | string, options: IPtyForkOptions | IWindowsPtyForkOptions): IPty;
+
+  export interface IBasePtyForkOptions {
+
+    /**
+     * Name of the terminal to be set in environment ($TERM variable).
+     */
+    name?: string;
+
+    /**
+     * Number of intial cols of the pty.
+     */
+    cols?: number;
+
+    /**
+     * Number of initial rows of the pty.
+     */
+    rows?: number;
+
+    /**
+     * Working directory to be set for the child program.
+     */
+    cwd?: string;
+
+    /**
+     * Environment to be set for the child program.
+     */
+    env?: { [key: string]: string | undefined };
+
+    /**
+     * String encoding of the underlying pty.
+     * If set, incoming data will be decoded to strings and outgoing strings to bytes applying this encoding.
+     * If unset, incoming data will be delivered as raw bytes (Buffer type).
+     * By default 'utf8' is assumed, to unset it explicitly set it to `null`.
+     */
+    encoding?: string | null;
+
+    /**
+     * (EXPERIMENTAL)
+     * Whether to enable flow control handling (false by default). If enabled a message of `flowControlPause`
+     * will pause the socket and thus blocking the child program execution due to buffer back pressure.
+     * A message of `flowControlResume` will resume the socket into flow mode.
+     * For performance reasons only a single message as a whole will match (no message part matching).
+     * If flow control is enabled the `flowControlPause` and `flowControlResume` messages are not forwarded to
+     * the underlying pseudoterminal.
+     */
+    handleFlowControl?: boolean;
+
+    /**
+     * (EXPERIMENTAL)
+     * The string that should pause the pty when `handleFlowControl` is true. Default is XOFF ('\x13').
+     */
+    flowControlPause?: string;
+
+    /**
+     * (EXPERIMENTAL)
+     * The string that should resume the pty when `handleFlowControl` is true. Default is XON ('\x11').
+     */
+    flowControlResume?: string;
+  }
+
+  export interface IPtyForkOptions extends IBasePtyForkOptions {
+    /**
+     * Security warning: use this option with great caution,
+     * as opened file descriptors with higher privileges might leak to the child program.
+     */
+    uid?: number;
+    gid?: number;
+  }
+
+  export interface IWindowsPtyForkOptions extends IBasePtyForkOptions {
+  /**
+   * Whether to use the ConPTY system on Windows. When this is not set, ConPTY will be used when
+   * the Windows build number is >= 18309 (instead of winpty). Note that ConPTY is available from
+   * build 17134 but is too unstable to enable by default.
+   *
+   * @deprecated This option is ignored and will be removed in a future version.
+   * https://github.com/microsoft/node-pty/issues/871
+   */
+    useConpty?: boolean;
+
+    /**
+     * (EXPERIMENTAL)
+     *
+     * Whether to use the conpty.dll shipped with the node-pty package instead of the one built into
+     * Windows. Defaults to false.
+     */
+    useConptyDll?: boolean;
+
+    /**
+     * Whether to use PSEUDOCONSOLE_INHERIT_CURSOR in conpty.
+     * @see https://docs.microsoft.com/en-us/windows/console/createpseudoconsole
+     */
+    conptyInheritCursor?: boolean;
+  }
+
+  /**
+   * An interface representing a pseudoterminal.
+   */
+  export interface IPty {
+    /**
+     * The process ID of the outer process.
+     */
+    readonly pid: number;
+
+    /**
+     * The column size in characters.
+     */
+    readonly cols: number;
+
+    /**
+     * The row size in characters.
+     */
+    readonly rows: number;
+
+    /**
+     * The title of the active process.
+     */
+    readonly process: string;
+
+    /**
+     * (EXPERIMENTAL)
+     * Whether to handle flow control. Useful to disable/re-enable flow control during runtime.
+     * Use this for binary data that is likely to contain the `flowControlPause` string by accident.
+     */
+    handleFlowControl: boolean;
+
+    /**
+     * Adds an event listener for when a data event fires. This happens when data is returned from
+     * the pty.
+     * @returns an `IDisposable` to stop listening.
+     */
+    readonly onData: IEvent<string>;
+
+    /**
+     * Adds an event listener for when an exit event fires. This happens when the pty exits.
+     * @returns an `IDisposable` to stop listening.
+     */
+    readonly onExit: IEvent<{ exitCode: number, signal?: number }>;
+
+    /**
+     * Resizes the dimensions of the pty.
+     * @param columns The number of columns to use.
+     * @param rows The number of rows to use.
+     * @param pixelSize Optional pixel dimensions of the pty. On Unix, this sets the `ws_xpixel`
+     * and `ws_ypixel` fields of the `winsize` struct. Applications running in the pty can read
+     * these values via the `TIOCGWINSZ` ioctl. This parameter is ignored on Windows.
+     */
+    resize(columns: number, rows: number, pixelSize?: { width: number, height: number }): void;
+
+    /**
+     * Clears the pty's internal representation of its buffer. This is a no-op
+     * unless on Windows/ConPTY. This is useful if the buffer is cleared on the
+     * frontend in order to synchronize state with the backend to avoid ConPTY
+     * possibly reprinting the screen.
+     */
+    clear(): void;
+
+    /**
+     * Writes data to the pty.
+     * @param data The data to write.
+     */
+    write(data: string | Buffer): void;
+
+    /**
+     * Kills the pty.
+     * @param signal The signal to use, defaults to SIGHUP. This parameter is not supported on
+     * Windows.
+     * @throws Will throw when signal is used on Windows.
+     */
+    kill(signal?: string): void;
+
+    /**
+     * Pauses the pty for customizable flow control.
+     */
+    pause(): void;
+
+    /**
+     * Resumes the pty for customizable flow control.
+     */
+    resume(): void;
+  }
+
+  /**
+   * An object that can be disposed via a dispose function.
+   */
+  export interface IDisposable {
+    dispose(): void;
+  }
+
+  /**
+   * An event that can be listened to.
+   * @returns an `IDisposable` to stop listening.
+   */
+  export interface IEvent<T> {
+    (listener: (e: T) => any): IDisposable;
+  }
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "pwragent",
-  "version": "0.0.0",
+  "version": "1.3.7",
   "private": false,
   "type": "module",
-  "description": "Coming soon: PwrAgent command-line tools.",
+  "description": "Experimental headless PwrAgent daemon and command-line client.",
   "author": "PwrDrvr LLC <harold@pwrdrvr.com>",
   "license": "MIT",
   "copyright": "Copyright (c) 2026 PwrDrvr LLC",
@@ -27,16 +27,43 @@
   },
   "files": [
     "bin",
+    "src",
+    "examples",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "dist",
+    "licenses"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org",
+    "tag": "latest"
   },
   "bin": {
     "pwragent": "bin/pwragent.js"
   },
   "scripts": {
-    "pack:check": "npm pack --dry-run"
+    "test": "node --test test/*.test.js scripts/*.test.mjs",
+    "pack:check": "node scripts/pack-check.mjs",
+    "build": "node scripts/build.mjs",
+    "pretest": "node scripts/build.mjs",
+    "prepack": "node scripts/build.mjs",
+    "release:check": "node scripts/release.mjs"
+  },
+  "devDependencies": {
+    "@pwragent/federation": "workspace:*",
+    "@pwragent/shared": "workspace:*",
+    "esbuild": "0.28.1",
+    "@pwragent/agent-tools": "workspace:*"
+  },
+  "dependencies": {
+    "node-pty": "1.2.0-beta.15"
+  },
+  "bundleDependencies": [
+    "node-pty"
+  ],
+  "pwragentRelease": {
+    "tag": "v1.3.7",
+    "commit": "e5a9fab9c90daa2f0bed661768969dc5c5301415"
   }
 }

package/src/cli.js

@@ -0,0 +1,123 @@
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { setTimeout as delay } from "node:timers/promises";
+import { call } from "./client.js";
+import { serve } from "./daemon.js";
+import { ACTIVE } from "./store.js";
+
+const help = `PwrAgent Headless (experimental, Linux/macOS, Node >=22)
+
+  pwragent serve --workspace /project --codex-home /codex-home --codex-bin /path/to/codex
+  pwragent project-list
+  pwragent project-create --name NAME [--label NAME]
+  pwragent project-clone --name NAME --remote URL [--label NAME]
+  pwragent project-add|project-remove --path /workspace/project
+  pwragent git-auth-configure --config-file /outpost/git-auth-settings.json
+  pwragent status | list
+  pwragent submit --id JOB --prompt-file /task.txt [--sandbox read-only|workspace-write]
+                  [--model MODEL] [--thread THREAD_ID] [--cwd /workspace/project]
+  pwragent show|read|interrupt|wait --id JOB
+  pwragent federation-join --invite-file /invite.txt --gateway ws://127.0.0.1:47830 [--label NAME]
+  pwragent federation-invite [--port 47831] [--label NAME]
+  pwragent federation-status | federation-leave
+  pwragent federation-revoke --peer INSTANCE_ID
+
+Use --profile NAME (or PWRAGENT_PROFILE, default: default).
+State: $PWRAGENT_HOME/profiles/NAME/state/headless (default root: ~/.pwragent).
+serve runs in the foreground; use systemd to own its lifetime remotely.
+submit returns durable acceptance. wait exits 0 only for completed, 2 otherwise.
+Approvals are never granted. Job IDs cannot be reused for different input.
+Federation uses private retained identity files and the standard encrypted protocol.
+No provisioning, login, queue, automatic replay, or local messaging providers.
+`;
+
+export async function main(args) {
+  const { values, positionals } = parseArgs({ args, allowPositionals: true, strict: true, options: {
+    help: { type: "boolean", short: "h" },
+    profile: { type: "string" },
+    workspace: { type: "string" },
+    "codex-home": { type: "string" },
+    "codex-bin": { type: "string" },
+    id: { type: "string" },
+    "prompt-file": { type: "string" },
+    thread: { type: "string" },
+    model: { type: "string" },
+    sandbox: { type: "string" },
+    "invite-file": { type: "string" },
+    gateway: { type: "string" },
+    label: { type: "string" },
+    port: { type: "string" },
+    peer: { type: "string" },
+    name: { type: "string" }, remote: { type: "string" }, path: { type: "string" }, cwd: { type: "string" }, "config-file": { type: "string" },
+  } });
+  if (values.help || !positionals.length) { console.log(help); return 0; }
+  if (positionals.length !== 1) throw new Error("Expected one command; see --help");
+  const command = positionals[0];
+  const allowed = {
+    serve: ["workspace", "codex-home", "codex-bin"],
+    submit: ["id", "prompt-file", "thread", "model", "sandbox", "cwd"],
+    "project-list": [], "project-create": ["name", "label"], "project-clone": ["name", "remote", "label"],
+    "project-add": ["path", "label"], "project-remove": ["path"], "git-auth-configure": ["config-file"],
+    show: ["id"], read: ["id"], interrupt: ["id"], wait: ["id"], status: [], list: [],
+    "federation-join": ["invite-file", "gateway", "label"],
+    "federation-invite": ["port", "label"],
+    "federation-status": [], "federation-leave": [], "federation-revoke": ["peer"],
+  };
+  if (!Object.hasOwn(allowed, command)) throw new Error(`Unknown command: ${command}`);
+  for (const option of Object.keys(values)) {
+    if (option !== "profile" && !allowed[command].includes(option)) throw new Error(`--${option} does not apply to ${command}`);
+  }
+  const profile = values.profile || process.env.PWRAGENT_PROFILE || "default";
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(profile)) throw new Error("Invalid profile name");
+  const root = process.env.PWRAGENT_HOME || path.join(homedir(), ".pwragent");
+  if (!path.isAbsolute(root)) throw new Error("PWRAGENT_HOME must be absolute");
+  const directory = path.join(root, "profiles", profile, "state", "headless");
+  if (command === "serve") {
+    return serve({ directory, workspace: values.workspace, home: values["codex-home"], command: values["codex-bin"], profile });
+  }
+  if (command.startsWith("project-") || command === "git-auth-configure") {
+    let params = { name: values.name, remote: values.remote, path: values.path, label: values.label };
+    if (command === "project-clone" && !values.remote) throw new Error("--remote is required");
+    if (command === "git-auth-configure") {
+      const file = values["config-file"];
+      if (!file || !statSync(file).isFile() || statSync(file).size > 16384) throw new Error("--config-file must name an outpost JSON file of at most 16 KiB");
+      params = JSON.parse(readFileSync(file, "utf8"));
+    }
+    console.log(JSON.stringify(await call(directory, command, params)));
+    return 0;
+  }
+  if (command.startsWith("federation-")) {
+    let invite;
+    if (command === "federation-join") {
+      const file = values["invite-file"];
+      if (!file || !statSync(file).isFile() || statSync(file).size > 64 * 1024) throw new Error("--invite-file must name a file of at most 64 KiB");
+      invite = readFileSync(file, "utf8").trim();
+    }
+    console.log(JSON.stringify(await call(directory, command, { invite, gateway: values.gateway, label: values.label,
+      port: values.port === undefined ? undefined : Number(values.port), peer: values.peer })));
+    return 0;
+  }
+  if (allowed[command].includes("id") && !values.id) throw new Error("--id is required");
+  if (command === "submit") {
+    const file = values["prompt-file"];
+    if (!file || !statSync(file).isFile() || statSync(file).size > 256 * 1024) throw new Error("--prompt-file must name a file of at most 256 KiB");
+    const result = await call(directory, "submit", { id: values.id, prompt: readFileSync(file, "utf8"),
+      threadId: values.thread, cwd: values.cwd, model: values.model, sandbox: values.sandbox });
+    console.log(JSON.stringify(result));
+    return 0;
+  }
+  if (command === "wait") {
+    for (;;) {
+      const job = await call(directory, "show", { id: values.id });
+      if (!ACTIVE.has(job.status)) {
+        console.log(JSON.stringify(job));
+        return job.status === "completed" ? 0 : 2;
+      }
+      await delay(1000);
+    }
+  }
+  console.log(JSON.stringify(await call(directory, command, { id: values.id })));
+  return 0;
+}

package/src/client.js

@@ -0,0 +1,27 @@
+import net from "node:net";
+import path from "node:path";
+import { readMessages, MAX_REQUEST_BYTES, MAX_RESPONSE_BYTES } from "./wire.js";
+
+export function call(directory, method, params = {}) {
+  const data = JSON.stringify({ version: 1, method, params }) + "\n";
+  if (Buffer.byteLength(data) > MAX_REQUEST_BYTES) return Promise.reject(new Error("Request exceeds 512 KiB"));
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(path.join(directory, "rpc.sock"));
+    let settled = false;
+    const finish = (error, result) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      if (error) reject(error); else resolve(result);
+    };
+    socket.setTimeout(45000, () => finish(new Error("Daemon request timed out; use the same job ID to check acceptance")));
+    socket.on("error", (error) => finish(new Error(`Cannot contact headless daemon (${error.code || error.message})`)));
+    socket.on("close", () => finish(new Error("Daemon disconnected; use the same job ID to check acceptance")));
+    socket.on("connect", () => socket.write(data));
+    readMessages(socket, MAX_RESPONSE_BYTES, (message) => {
+      if (typeof message.error === "string") finish(new Error(message.error));
+      else if ("result" in message) finish(null, message.result);
+      else finish(new Error("Invalid daemon response"));
+    }, (error) => finish(error));
+  });
+}