@preapexis/piexis 0.2.4 → 0.2.5

package/bin/piexis-web.mjs

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { randomBytes } from "node:crypto";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const args = process.argv.slice(2);
+const value = (flag) => { const index = args.indexOf(flag); return index < 0 ? undefined : args[index + 1]; };
+if (args.includes("--help") || args.includes("-h")) {
+  console.log("Usage: piexis-web [--workspace <directory>] [--port <port>] [--token <token>]");
+  process.exit(0);
+}
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const workspace = path.resolve(value("--workspace") || process.cwd());
+const port = value("--port") || process.env.PIXIS_PORT || "4317";
+const token = value("--token") || process.env.PIXIS_TOKEN || randomBytes(32).toString("base64url");
+const server = path.join(root, "apps", "server", "src", "index.ts");
+const child = spawn(process.execPath, ["--import", "tsx", server], {
+  cwd: workspace,
+  env: { ...process.env, PIXIS_WORKSPACE: workspace, PIXIS_PORT: port, PIXIS_TOKEN: token, PIXIS_ORIGIN: `http://127.0.0.1:${port}` },
+  stdio: "inherit",
+  windowsHide: true
+});
+child.on("exit", (code) => process.exitCode = code ?? 1);

package/extensions/webui.ts

@@ -0,0 +1,45 @@
+import { randomBytes } from "node:crypto";
+import { spawn, type ChildProcess } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:net";
+import path from "node:path";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+async function availablePort(): Promise<number> {
+  const server = createServer();
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => resolve());
+  });
+  const address = server.address();
+  await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
+  if (!address || typeof address === "string") throw new Error("Could not select a local PIXIS WebUI port.");
+  return address.port;
+}
+
+/** Starts the separate local WebUI; Pi's TUI remains usable in this process. */
+export default function webui(pi: ExtensionAPI) {
+  const servers = new Map<string, ChildProcess>();
+  const launcher = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../bin/piexis-web.mjs");
+
+  pi.registerCommand("webui", {
+    description: "Start the local PIXIS WebUI for this workspace",
+    handler: async (_args, ctx) => {
+      const running = servers.get(ctx.cwd);
+      if (running && running.exitCode === null && !running.killed) {
+        ctx.ui.notify("PIXIS WebUI is already running for this workspace.", "info");
+        return;
+      }
+      const token = randomBytes(32).toString("base64url");
+      const port = await availablePort();
+      const child = spawn(process.execPath, [launcher, "--workspace", ctx.cwd, "--port", `${port}`, "--token", token], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      });
+      child.unref();
+      servers.set(ctx.cwd, child);
+      ctx.ui.notify(`PIXIS WebUI started: http://127.0.0.1:${port}/#token=${token}`, "info");
+    }
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@preapexis/piexis",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "type": "module",
   "description": "Extensions, skills, prompts, and themes for pi",
   "repository": {
@@ -11,6 +11,21 @@
     "pi-package"
   ],
   "license": "MIT",
+  "bin": {
+    "piexis-web": "./bin/piexis-web.mjs"
+  },
+  "files": [
+    "apps/server/",
+    "apps/web/dist/",
+    "bin/",
+    "extensions/",
+    "lib/",
+    "packages/",
+    "prompts/",
+    "schemas/",
+    "skills/",
+    "themes/"
+  ],
   "engines": {
     "node": ">=22.19.0"
   },
@@ -21,7 +36,13 @@
   },
   "scripts": {
     "test": "node --test tests/*.test.mjs",
+    "test:webui": "node --import tsx --test tests/webui/*.test.ts",
     "check": "tsc --noEmit",
+    "check:server": "tsc -p apps/server/tsconfig.json --noEmit",
+    "check:web": "tsc -p apps/web/tsconfig.json --noEmit",
+    "build": "vite build --config apps/web/vite.config.ts",
+    "prepack": "npm run build",
+    "dev": "node scripts/dev.mjs",
     "release": "node scripts/release.mjs"
   },
   "pi": {
@@ -29,7 +50,8 @@
       "./extensions/ask-question.ts",
       "./extensions/ui.ts",
       "./extensions/recommended-tools.ts",
-      "./extensions/agents.ts"
+      "./extensions/agents.ts",
+      "./extensions/webui.ts"
     ],
     "skills": [
       "./skills"
@@ -43,6 +65,19 @@
   },
   "devDependencies": {
     "@types/node": "24.10.0",
-    "typescript": "5.9.3"
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.1.2",
+    "typescript": "5.9.3",
+    "vite": "^8.3.4"
+  },
+  "dependencies": {
+    "@fastify/static": "^10.1.6",
+    "@fastify/websocket": "^11.3.4",
+    "fastify": "^5.12.5",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "tsx": "^4.23.15",
+    "zod": "^4.6.5"
   }
 }

package/packages/pi-integration/src/rpc-client.ts

@@ -0,0 +1,99 @@
+import { ChildProcess, spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+
+export interface RpcResponse {
+  type: "response";
+  id?: string;
+  command: string;
+  success: boolean;
+  data?: unknown;
+  error?: string;
+}
+
+export type RpcRecord = Record<string, unknown>;
+
+/** Long-lived, documented Pi RPC client. It treats stdout as strict JSONL. */
+export class PiRpcClient extends EventEmitter {
+  #child?: ChildProcess;
+  #buffer = "";
+  #pending = new Map<string, { resolve: (value: RpcResponse) => void; reject: (reason: Error) => void }>();
+
+  constructor(
+    private readonly cwd: string,
+    private readonly executable = process.env.PIXIS_PI_BIN || (process.platform === "win32" ? "pi.cmd" : "pi"),
+    private readonly executableArgs: string[] = []
+  ) {
+    super();
+  }
+
+  start(): void {
+    if (this.#child) return;
+    const child = spawn(this.executable, [...this.executableArgs, "--mode", "rpc"], { cwd: this.cwd, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+    this.#child = child;
+    child.stdout?.on("data", (chunk: Buffer) => this.#consume(chunk.toString("utf8")));
+    child.stderr?.on("data", (chunk: Buffer) => this.emit("diagnostic", chunk.toString("utf8")));
+    child.on("error", (error) => this.#fail(error));
+    child.on("exit", (code, signal) => this.#fail(new Error(`Pi exited (${code ?? signal ?? "unknown"})`)));
+  }
+
+  async command(command: Record<string, unknown>): Promise<RpcResponse> {
+    this.start();
+    const id = randomUUID();
+    const record = { ...command, id };
+    return new Promise((resolve, reject) => {
+      this.#pending.set(id, { resolve, reject });
+      const input = this.#child?.stdin;
+      if (!input || input.destroyed) return reject(new Error("Pi RPC stdin is unavailable"));
+      input.write(`${JSON.stringify(record)}\n`, "utf8", (error) => {
+        if (error) {
+          this.#pending.delete(id);
+          reject(error);
+        }
+      });
+    });
+  }
+
+  send(record: Record<string, unknown>): void {
+    const input = this.#child?.stdin;
+    if (!input || input.destroyed) throw new Error("Pi RPC stdin is unavailable");
+    input.write(`${JSON.stringify(record)}\n`, "utf8");
+  }
+
+  dispose(): void {
+    this.#child?.stdin?.end();
+    this.#child = undefined;
+  }
+
+  #consume(chunk: string): void {
+    this.#buffer += chunk;
+    let newline: number;
+    while ((newline = this.#buffer.indexOf("\n")) >= 0) {
+      const line = this.#buffer.slice(0, newline).replace(/\r$/, "");
+      this.#buffer = this.#buffer.slice(newline + 1);
+      if (!line) continue;
+      try {
+        const record = JSON.parse(line) as RpcRecord;
+        if (record.type === "response" && typeof record.id === "string" && typeof record.command === "string" && typeof record.success === "boolean") {
+          const pending = this.#pending.get(record.id);
+          if (pending) {
+            this.#pending.delete(record.id);
+            pending.resolve(record as unknown as RpcResponse);
+            continue;
+          }
+        }
+        this.emit("record", record);
+      } catch {
+        this.emit("diagnostic", `Ignoring malformed Pi RPC record: ${line.slice(0, 200)}`);
+      }
+    }
+  }
+
+  #fail(error: Error): void {
+    if (!this.#child && this.#pending.size === 0) return;
+    this.#child = undefined;
+    for (const { reject } of this.#pending.values()) reject(error);
+    this.#pending.clear();
+    this.emit("exit", error);
+  }
+}

package/packages/shared/src/index.ts

@@ -0,0 +1,27 @@
+export type SessionStatus = "starting" | "ready" | "running" | "waiting" | "cancelling" | "failed" | "stopped";
+
+export interface SessionSummary {
+  id: string;
+  name: string;
+  status: SessionStatus;
+  model?: string;
+  sessionFile?: string;
+}
+
+export type ClientCommand =
+  | { type: "list_sessions" }
+  | { type: "subscribe"; sessionId: string }
+  | { type: "create_session" }
+  | { type: "prompt"; sessionId: string; message: string }
+  | { type: "abort"; sessionId: string }
+  | { type: "extension_ui_response"; sessionId: string; id: string; value?: string; confirmed?: boolean; cancelled?: boolean }
+  | { type: "git_status"; sessionId: string }
+  | { type: "git_diff"; sessionId: string; path: string };
+
+export type ServerMessage =
+  | { type: "snapshot"; sessions: SessionSummary[]; sessionId: string; state: unknown; messages: unknown[] }
+  | { type: "session"; session: SessionSummary }
+  | { type: "pi_event"; sessionId: string; event: unknown }
+  | { type: "extension_ui"; sessionId: string; request: unknown }
+  | { type: "workspace"; sessionId: string; action: "git_status" | "git_diff"; data: unknown }
+  | { type: "error"; message: string; sessionId?: string };

package/themes/midnight.json

@@ -0,0 +1,81 @@
+{
+  "$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  "name": "midnight",
+  "vars": {
+    "cyan": "#67d9ef",
+    "violet": "#bb9af7",
+    "blue": "#7aa2f7",
+    "ink": "#141821",
+    "panel": "#1c2230",
+    "panelRaised": "#2c3548",
+    "text": "#e2e8f0",
+    "muted": "#a9b7cc",
+    "dim": "#7e8da6",
+    "mint": "#88dfb3",
+    "rose": "#ff859d",
+    "gold": "#f5ce7b"
+  },
+  "colors": {
+    "accent": "cyan",
+    "border": "blue",
+    "borderAccent": "cyan",
+    "borderMuted": "dim",
+    "success": "mint",
+    "error": "rose",
+    "warning": "gold",
+    "muted": "muted",
+    "dim": "dim",
+    "text": "text",
+    "thinkingText": "muted",
+    "selectedBg": "panelRaised",
+    "scrollbarTrack": "panel",
+    "scrollbarThumb": "blue",
+    "searchMatchBg": "#3c3655",
+    "searchMatchText": "text",
+    "userMessageBg": "panel",
+    "userMessageText": "text",
+    "customMessageBg": "#232337",
+    "customMessageText": "text",
+    "customMessageLabel": "violet",
+    "toolPendingBg": "#232b3c",
+    "toolSuccessBg": "#1c302b",
+    "toolErrorBg": "#37242f",
+    "toolTitle": "cyan",
+    "toolOutput": "muted",
+    "mdHeading": "violet",
+    "mdLink": "cyan",
+    "mdLinkUrl": "muted",
+    "mdCode": "mint",
+    "mdCodeBlock": "text",
+    "mdCodeBlockBorder": "blue",
+    "mdQuote": "muted",
+    "mdQuoteBorder": "violet",
+    "mdHr": "dim",
+    "mdListBullet": "cyan",
+    "toolDiffAdded": "mint",
+    "toolDiffRemoved": "rose",
+    "toolDiffContext": "muted",
+    "syntaxComment": "dim",
+    "syntaxKeyword": "violet",
+    "syntaxFunction": "blue",
+    "syntaxVariable": "text",
+    "syntaxString": "mint",
+    "syntaxNumber": "gold",
+    "syntaxType": "cyan",
+    "syntaxOperator": "cyan",
+    "syntaxPunctuation": "muted",
+    "thinkingOff": "dim",
+    "thinkingMinimal": "muted",
+    "thinkingLow": "blue",
+    "thinkingMedium": "cyan",
+    "thinkingHigh": "violet",
+    "thinkingXhigh": "rose",
+    "thinkingMax": "gold",
+    "bashMode": "gold"
+  },
+  "export": {
+    "pageBg": "ink",
+    "cardBg": "panel",
+    "infoBg": "panelRaised"
+  }
+}

package/.github/workflows/publish.yml

@@ -1,35 +0,0 @@
-name: Publish npm package
-
-on:
-  push:
-    tags:
-      - "v*"
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-      id-token: write
-
-    steps:
-      - uses: actions/checkout@v6
-
-      - uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          registry-url: https://registry.npmjs.org
-          package-manager-cache: false
-
-      - run: npm ci --ignore-scripts
-      - run: npm run check
-      - run: npm test
-
-      - name: Verify version tag
-        run: |
-          VERSION=$(node -p "require('./package.json').version")
-          TAG=${GITHUB_REF_NAME#v}
-          test "$VERSION" = "$TAG"
-
-      - run: npm publish --access public

package/AGENTS.md

@@ -1,38 +0,0 @@
-# Agents Guide
-
-## Project and layout
-
-Piexis (`@preapexis/piexis`) is a TypeScript Pi package providing interactive questions, UI extensions, skills, prompts, and themes. Node.js 22.19+ and a current Pi release are required.
-
-- `extensions/ask-question.ts`: sequential interactive `AskQuestion` tool; requires the TUI.
-- `extensions/agents.ts`: five agent profiles and sequential subprocess subagents; `lib/agents.ts` owns configuration/routing, and `lib/subagent-runner.ts` owns protocol/cancellation. User/project `agent.json` files configure models and effort, with legacy `agents.json` fallback. Accepted project setup creates a missing `.pi/agent.json` scaffold without overwriting existing configuration.
-- `extensions/ui.ts`: project header, activity footer, Git branch, model, and context usage.
-- `extensions/recommended-tools.ts`: automatic opt-in project setup for Pi's native `grep`, `find`, and `ls` tools.
-- `skills/`: task-specific `SKILL.md` guidance.
-- `prompts/`: bundled `/init`, `/commit`, and `/summary` prompts.
-- `themes/orange.json`: bundled theme.
-- `package.json`: resource manifest and npm scripts; `tsconfig.json`: strict TypeScript configuration.
-
-## Development
-
-| Command | Purpose |
-| --- | --- |
-| `npm ci --ignore-scripts` | Install locked dependencies without lifecycle scripts. |
-| `npm run check` | Type-check with `tsc --noEmit`. |
-| `npm test` | Run `node --test tests/*.test.mjs`. |
-| `pi -e ./extensions/ask-question.ts` | Preview only the question extension. |
-
-There are no separate build, lint, or format scripts, and no CI configuration in this checkout.
-
-## Conventions and safety
-
-- Use ESM and strict TypeScript with NodeNext module resolution and ES2022 targeting. Local imports use explicit `.ts` extensions.
-- Match nearby source style: two-space indentation, double-quoted strings, and semicolons. Extensions export a default registration function receiving `ExtensionAPI`.
-- Preserve interactive cancellation and non-TUI handling. Add or update `node:test`/`node:assert/strict` tests for behavior changes, using disposable fixtures rather than credentials.
-- Preserve unrelated working-tree changes and intentional deletions. Do not commit generated output, secrets, dependency directories, or local configuration. `.pi/` and `.kilo/` are ignored local state, not package resources.
-- Permission modes, approval/classifier logic, plan execution handoffs, and background workers have been removed. Piexis does not enforce tool-access restrictions or provide sandboxing; respect host restrictions and other installed extensions.
-- Do not delete existing user settings, session records, or retained task worktrees as part of routine package changes.
-
-## Validation
-
-Run `npm run check` and relevant tests for implementation changes. Report unexecuted checks explicitly; skipped or empty runs do not establish coverage. Review the diff for credentials and unrelated changes before finishing.

package/scripts/release.mjs

@@ -1,32 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-
-const bump = process.argv[2] ?? "patch";
-if (!["patch", "minor", "major"].includes(bump)) {
-  console.error("Usage: npm run release -- [patch|minor|major]");
-  process.exit(1);
-}
-
-function run(command, args) {
-  const result = spawnSync(command, args, { stdio: "inherit", shell: false });
-  if (result.error) throw result.error;
-  if (result.status !== 0) process.exit(result.status ?? 1);
-}
-
-const status = spawnSync("git", ["status", "--porcelain"], { encoding: "utf8" });
-if (status.status !== 0) process.exit(status.status ?? 1);
-if (status.stdout.trim()) {
-  console.error("Working tree is not clean. Commit or stash changes first.");
-  process.exit(1);
-}
-
-console.log("Running checks...");
-run("npm", ["run", "check"]);
-run("npm", ["test"]);
-
-console.log(`Bumping ${bump} version and creating a Git tag...`);
-run("npm", ["version", bump]);
-
-const packageJson = JSON.parse(readFileSync("package.json", "utf8"));
-console.log(`Pushing v${packageJson.version}; GitHub Actions will publish it.`);
-run("git", ["push", "origin", "HEAD", "--follow-tags"]);