pi-webdesk 0.1.0

package/dist/packages/pi-bridge/src/errors.js

@@ -0,0 +1,19 @@
+// packages/pi-bridge/src/errors.ts
+var PiBridgeError = class extends Error {
+  code;
+  details;
+  constructor(code, message, options) {
+    super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "PiBridgeError";
+    this.code = code;
+    this.details = options?.details ?? {};
+  }
+};
+function isPiBridgeError(value, code) {
+  if (!(value instanceof PiBridgeError)) return false;
+  return code === void 0 || value.code === code;
+}
+export {
+  PiBridgeError,
+  isPiBridgeError
+};

package/dist/packages/pi-bridge/src/handshake.js

@@ -0,0 +1,43 @@
+// packages/pi-bridge/src/handshake.ts
+import { z } from "zod";
+var PITA_POLICY_STATUS_KEY = "pita-policy";
+var PITA_POLICY_PROTOCOL = "pita-policy";
+var PITA_POLICY_VERSION = 1;
+var pitaRuntimeModeSchema = z.enum(["supervised", "trusted"]);
+var pitaPolicyStatusSchema = z.looseObject({
+  protocol: z.literal(PITA_POLICY_PROTOCOL),
+  version: z.number().int().positive(),
+  mode: pitaRuntimeModeSchema
+});
+function isSupportedPolicyVersion(version) {
+  return version === PITA_POLICY_VERSION;
+}
+function encodePolicyStatus(status) {
+  return JSON.stringify(status);
+}
+function decodePolicyStatus(statusText) {
+  if (statusText === void 0) {
+    return { ok: false, reason: "handshake statusText is missing" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(statusText);
+  } catch {
+    return { ok: false, reason: `handshake statusText is not valid JSON: ${statusText}` };
+  }
+  const result = pitaPolicyStatusSchema.safeParse(parsed);
+  if (!result.success) {
+    return { ok: false, reason: `handshake payload is malformed: ${result.error.message}` };
+  }
+  return { ok: true, status: result.data };
+}
+export {
+  PITA_POLICY_PROTOCOL,
+  PITA_POLICY_STATUS_KEY,
+  PITA_POLICY_VERSION,
+  decodePolicyStatus,
+  encodePolicyStatus,
+  isSupportedPolicyVersion,
+  pitaPolicyStatusSchema,
+  pitaRuntimeModeSchema
+};

package/dist/packages/pi-bridge/src/index.js

@@ -0,0 +1,76 @@
+// packages/pi-bridge/src/index.ts
+import { PiBridgeError, isPiBridgeError } from "./errors.js";
+import {
+  createPiAuthManager
+} from "./auth.js";
+import { JsonlDecoder } from "./jsonl.js";
+import {
+  PITA_POLICY_APPROVAL_PROTOCOL,
+  PITA_POLICY_APPROVAL_TITLE,
+  MAX_POLICY_APPROVAL_SUMMARY_CHARS,
+  MAX_POLICY_APPROVAL_TIMEOUT_MS,
+  decodePolicyApproval,
+  encodePolicyApproval,
+  sanitizeApprovalDisplayText
+} from "./policy-approval.js";
+import {
+  PITA_POLICY_PROTOCOL,
+  PITA_POLICY_STATUS_KEY,
+  PITA_POLICY_VERSION,
+  decodePolicyStatus,
+  encodePolicyStatus,
+  isSupportedPolicyVersion,
+  pitaPolicyStatusSchema,
+  pitaRuntimeModeSchema
+} from "./handshake.js";
+import {
+  DEFAULT_POLICY_EXTENSION_PATH,
+  createPiRpcRuntime
+} from "./rpc/runtime.js";
+import {
+  PI_EXECUTABLE_ENV_VAR,
+  resolvePiInvocation
+} from "./resolve.js";
+import {
+  createPiConfigurationInspector,
+  inspectPiConfigurationInProcess
+} from "./resources.js";
+import {
+  MAX_PI_SESSION_CATALOG_ENTRIES,
+  PI_SESSION_DIRECTORY_ENV,
+  createPiSessionCatalog,
+  forkPiSessionInProcess,
+  inspectPiSessionsInProcess
+} from "./sessions.js";
+export {
+  DEFAULT_POLICY_EXTENSION_PATH,
+  JsonlDecoder,
+  MAX_PI_SESSION_CATALOG_ENTRIES,
+  MAX_POLICY_APPROVAL_SUMMARY_CHARS,
+  MAX_POLICY_APPROVAL_TIMEOUT_MS,
+  PITA_POLICY_APPROVAL_PROTOCOL,
+  PITA_POLICY_APPROVAL_TITLE,
+  PITA_POLICY_PROTOCOL,
+  PITA_POLICY_STATUS_KEY,
+  PITA_POLICY_VERSION,
+  PI_EXECUTABLE_ENV_VAR,
+  PI_SESSION_DIRECTORY_ENV,
+  PiBridgeError,
+  createPiAuthManager,
+  createPiConfigurationInspector,
+  createPiRpcRuntime,
+  createPiSessionCatalog,
+  decodePolicyApproval,
+  decodePolicyStatus,
+  encodePolicyApproval,
+  encodePolicyStatus,
+  forkPiSessionInProcess,
+  inspectPiConfigurationInProcess,
+  inspectPiSessionsInProcess,
+  isPiBridgeError,
+  isSupportedPolicyVersion,
+  pitaPolicyStatusSchema,
+  pitaRuntimeModeSchema,
+  resolvePiInvocation,
+  sanitizeApprovalDisplayText
+};

package/dist/packages/pi-bridge/src/jsonl.js

@@ -0,0 +1,105 @@
+// packages/pi-bridge/src/jsonl.ts
+import { StringDecoder } from "node:string_decoder";
+import { PiBridgeError } from "./errors.js";
+var DEFAULT_MAX_RECORD_BYTES = 8 * 1024 * 1024;
+function snippet(text) {
+  return text.length <= 160 ? text : `${text.slice(0, 160)}\u2026`;
+}
+var JsonlDecoder = class {
+  #utf8 = new StringDecoder("utf8");
+  #buffer = "";
+  #failed = false;
+  #maxRecordBytes;
+  constructor(options = {}) {
+    this.#maxRecordBytes = options.maxRecordBytes ?? DEFAULT_MAX_RECORD_BYTES;
+  }
+  /**
+   * Feeds a chunk and returns every complete record it finished. Throws a
+   * `PiBridgeError` on malformed or oversized records; after a throw the
+   * decoder is permanently failed and must not be reused.
+   */
+  push(chunk) {
+    this.#assertUsable();
+    this.#buffer += typeof chunk === "string" ? chunk : this.#utf8.write(chunk);
+    const records = [];
+    let newlineIndex = this.#buffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      let line = this.#buffer.slice(0, newlineIndex);
+      this.#buffer = this.#buffer.slice(newlineIndex + 1);
+      if (line.endsWith("\r")) line = line.slice(0, -1);
+      records.push(this.#parseRecord(line));
+      newlineIndex = this.#buffer.indexOf("\n");
+    }
+    if (Buffer.byteLength(this.#buffer, "utf8") > this.#maxRecordBytes) {
+      this.#fail(
+        new PiBridgeError(
+          "PI_JSONL_OVERSIZED_RECORD",
+          `JSONL record exceeds ${this.#maxRecordBytes} bytes without a newline`,
+          { details: { maxRecordBytes: this.#maxRecordBytes } }
+        )
+      );
+    }
+    return records;
+  }
+  /**
+   * Signals end of stream. Throws if a non-empty partial record was pending,
+   * which means the stream was truncated mid-record.
+   */
+  end() {
+    this.#assertUsable();
+    this.#buffer += this.#utf8.end();
+    if (this.#buffer.length > 0) {
+      const partial = this.#buffer;
+      this.#buffer = "";
+      this.#fail(
+        new PiBridgeError(
+          "PI_JSONL_TRUNCATED_STREAM",
+          `JSONL stream ended with a partial record: ${snippet(partial)}`,
+          { details: { partial: snippet(partial) } }
+        )
+      );
+    }
+  }
+  #parseRecord(line) {
+    if (Buffer.byteLength(line, "utf8") > this.#maxRecordBytes) {
+      this.#fail(
+        new PiBridgeError(
+          "PI_JSONL_OVERSIZED_RECORD",
+          `JSONL record exceeds ${this.#maxRecordBytes} bytes`,
+          { details: { maxRecordBytes: this.#maxRecordBytes } }
+        )
+      );
+    }
+    if (line.length === 0) {
+      this.#fail(
+        new PiBridgeError("PI_JSONL_MALFORMED_RECORD", "JSONL stream contained an empty record")
+      );
+    }
+    try {
+      return JSON.parse(line);
+    } catch (cause) {
+      this.#fail(
+        new PiBridgeError(
+          "PI_JSONL_MALFORMED_RECORD",
+          `JSONL record is not valid JSON: ${snippet(line)}`,
+          { cause, details: { record: snippet(line) } }
+        )
+      );
+    }
+  }
+  #assertUsable() {
+    if (this.#failed) {
+      throw new PiBridgeError(
+        "PI_PROTOCOL_VIOLATION",
+        "JsonlDecoder cannot be used after a decode failure"
+      );
+    }
+  }
+  #fail(error) {
+    this.#failed = true;
+    throw error;
+  }
+};
+export {
+  JsonlDecoder
+};

package/dist/packages/pi-bridge/src/policy-approval.js

@@ -0,0 +1,62 @@
+// packages/pi-bridge/src/policy-approval.ts
+import { z } from "zod";
+var PITA_POLICY_APPROVAL_PROTOCOL = "pita-policy-approval-v1";
+var PITA_POLICY_APPROVAL_TITLE = "Pita supervised approval";
+var MAX_POLICY_APPROVAL_SUMMARY_CHARS = 1e5;
+var MAX_POLICY_APPROVAL_TIMEOUT_MS = 10 * 6e4;
+var unsafeDisplayCharacter = /[\p{Cc}\p{Cf}\p{Default_Ignorable_Code_Point}]/u;
+function sanitizeApprovalDisplayText(value) {
+  let safe = "";
+  for (const character of value) {
+    if (character === "\n" || character === "	") {
+      safe += character;
+    } else if (unsafeDisplayCharacter.test(character)) {
+      safe += `\\u{${character.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}}`;
+    } else {
+      safe += character;
+    }
+  }
+  return safe;
+}
+var policyApprovalSchema = z.object({
+  protocol: z.literal(PITA_POLICY_APPROVAL_PROTOCOL),
+  toolCallId: z.string().min(1).max(500),
+  toolName: z.string().min(1).max(200),
+  summary: z.string().min(1).max(MAX_POLICY_APPROVAL_SUMMARY_CHARS),
+  requestedAtMs: z.number().int().nonnegative(),
+  timeoutMs: z.number().int().positive().max(MAX_POLICY_APPROVAL_TIMEOUT_MS)
+}).strict();
+function encodePolicyApproval(approval) {
+  return JSON.stringify(
+    policyApprovalSchema.parse({
+      protocol: PITA_POLICY_APPROVAL_PROTOCOL,
+      ...approval,
+      toolName: sanitizeApprovalDisplayText(approval.toolName),
+      summary: sanitizeApprovalDisplayText(approval.summary)
+    })
+  );
+}
+function decodePolicyApproval(title, message) {
+  if (title !== PITA_POLICY_APPROVAL_TITLE || message === void 0) return null;
+  try {
+    const parsed = policyApprovalSchema.safeParse(JSON.parse(message));
+    if (!parsed.success) return null;
+    const normalized = policyApprovalSchema.safeParse({
+      ...parsed.data,
+      toolName: sanitizeApprovalDisplayText(parsed.data.toolName),
+      summary: sanitizeApprovalDisplayText(parsed.data.summary)
+    });
+    return normalized.success ? normalized.data : null;
+  } catch {
+    return null;
+  }
+}
+export {
+  MAX_POLICY_APPROVAL_SUMMARY_CHARS,
+  MAX_POLICY_APPROVAL_TIMEOUT_MS,
+  PITA_POLICY_APPROVAL_PROTOCOL,
+  PITA_POLICY_APPROVAL_TITLE,
+  decodePolicyApproval,
+  encodePolicyApproval,
+  sanitizeApprovalDisplayText
+};

package/dist/packages/pi-bridge/src/resolve.js

@@ -0,0 +1,59 @@
+// packages/pi-bridge/src/resolve.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { PiBridgeError } from "./errors.js";
+var PI_EXECUTABLE_ENV_VAR = "PITA_PI_EXECUTABLE";
+var PI_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
+function defaultResolveModulePath(specifier) {
+  return fileURLToPath(import.meta.resolve(specifier));
+}
+function resolvePiInvocation(options = {}) {
+  const env = options.env ?? process.env;
+  const fileExists = options.fileExists ?? existsSync;
+  const fromEnv = env[PI_EXECUTABLE_ENV_VAR];
+  if (fromEnv !== void 0 && fromEnv.trim() !== "") {
+    const executable = fromEnv.trim();
+    if (!fileExists(executable)) {
+      throw new PiBridgeError(
+        "PI_EXECUTABLE_NOT_FOUND",
+        `${PI_EXECUTABLE_ENV_VAR} points to ${executable}, but no file exists there.`,
+        { details: { executable } }
+      );
+    }
+    return {
+      executable,
+      prependArgs: [],
+      source: "env",
+      description: `${PI_EXECUTABLE_ENV_VAR} (${executable})`
+    };
+  }
+  const resolveModulePath = options.resolveModulePath ?? defaultResolveModulePath;
+  let entryPath = null;
+  try {
+    entryPath = resolveModulePath(PI_PACKAGE_NAME);
+  } catch {
+    entryPath = null;
+  }
+  if (entryPath !== null) {
+    const cliPath = path.join(path.dirname(entryPath), "cli.js");
+    if (fileExists(cliPath)) {
+      return {
+        executable: options.nodeExecutable ?? process.execPath,
+        prependArgs: [cliPath],
+        source: "workspace",
+        description: `workspace-local Pi (${cliPath})`
+      };
+    }
+  }
+  return {
+    executable: "pi",
+    prependArgs: [],
+    source: "path",
+    description: "pi on PATH"
+  };
+}
+export {
+  PI_EXECUTABLE_ENV_VAR,
+  resolvePiInvocation
+};

package/dist/packages/pi-bridge/src/resources-child.mjs

@@ -0,0 +1,23 @@
+// packages/pi-bridge/src/resources-child.mjs
+import process from "node:process";
+import { inspectPiConfigurationInProcess } from "./resources.js";
+var MAX_REQUEST_BYTES = 16 * 1024;
+var input = "";
+process.stdin.setEncoding("utf8");
+for await (const chunk of process.stdin) {
+  input += chunk;
+  if (Buffer.byteLength(input, "utf8") > MAX_REQUEST_BYTES) {
+    process.exitCode = 1;
+    break;
+  }
+}
+if (process.exitCode !== 1) {
+  try {
+    const request = JSON.parse(input);
+    if (typeof request?.cwd !== "string") throw new Error("missing cwd");
+    const result = await inspectPiConfigurationInProcess({ cwd: request.cwd });
+    process.stdout.write(JSON.stringify(result));
+  } catch {
+    process.exitCode = 1;
+  }
+}