pipane 0.1.0

package/dist/server/server/local-settings.js

@@ -0,0 +1,376 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const VALID_COLOR_THEMES = ["default", "gruvbox"];
+const VALID_DARK_MODES = ["light", "dark", "system"];
+const DEFAULT_SESSIONS_PER_PROJECT = 5;
+const DEFAULT_SETTINGS = {
+    version: 1,
+    sidebar: {
+        cwdTitle: {
+            filters: [],
+        },
+        sessionsPerProject: DEFAULT_SESSIONS_PER_PROJECT,
+    },
+    canvas: {
+        enabled: false,
+    },
+    appearance: {
+        colorTheme: "gruvbox",
+        darkMode: "dark",
+        showTokenUsage: true,
+    },
+};
+export function getLocalSettingsPath(homeDir = os.homedir()) {
+    return path.join(homeDir, ".piweb", "settings.json");
+}
+export function formatSettingsJson(settings) {
+    return `${JSON.stringify(settings, null, 2)}\n`;
+}
+export function normalizeCwdForDisplay(cwd, homeDir = os.homedir()) {
+    if (!cwd)
+        return cwd;
+    if (!homeDir)
+        return cwd;
+    if (cwd === homeDir)
+        return "~";
+    if (cwd.startsWith(`${homeDir}/`))
+        return `~${cwd.slice(homeDir.length)}`;
+    return cwd;
+}
+export function applyCwdFilters(input, filters) {
+    let out = input;
+    for (const filter of filters) {
+        out = out.replace(filter.re, filter.replacement);
+    }
+    return out;
+}
+export class LocalSettingsStore {
+    settingsPath;
+    homeDir;
+    currentSettings = structuredClone(DEFAULT_SETTINGS);
+    compiledFilters = [];
+    loadErrors = [];
+    constructor(opts) {
+        this.homeDir = opts?.homeDir ?? os.homedir();
+        this.settingsPath = opts?.settingsPath ?? getLocalSettingsPath(this.homeDir);
+        this.loadFromDisk();
+    }
+    get path() {
+        return this.settingsPath;
+    }
+    get settings() {
+        return this.currentSettings;
+    }
+    get errors() {
+        return [...this.loadErrors];
+    }
+    get canvasEnabled() {
+        return this.currentSettings.canvas.enabled;
+    }
+    formatCwdTitle(cwd) {
+        const normalized = normalizeCwdForDisplay(cwd, this.homeDir);
+        return applyCwdFilters(normalized, this.compiledFilters);
+    }
+    read() {
+        return {
+            path: this.settingsPath,
+            exists: existsSync(this.settingsPath),
+            errors: [...this.loadErrors],
+            settings: this.currentSettings,
+            formatted: formatSettingsJson(this.currentSettings),
+        };
+    }
+    loadFromDisk() {
+        if (!existsSync(this.settingsPath)) {
+            this.currentSettings = structuredClone(DEFAULT_SETTINGS);
+            this.compiledFilters = [];
+            this.loadErrors = [];
+            return;
+        }
+        let content;
+        try {
+            content = readFileSync(this.settingsPath, "utf8");
+        }
+        catch (err) {
+            this.currentSettings = structuredClone(DEFAULT_SETTINGS);
+            this.compiledFilters = [];
+            this.loadErrors = [
+                `Failed to read local settings at ${this.settingsPath}: ${String(err?.message ?? err)}`,
+            ];
+            return;
+        }
+        const result = this.validate(content);
+        if (!result.valid || !result.settings) {
+            this.currentSettings = structuredClone(DEFAULT_SETTINGS);
+            this.compiledFilters = [];
+            this.loadErrors = result.errors;
+            return;
+        }
+        this.currentSettings = result.settings;
+        this.compiledFilters = compileFilters(result.settings);
+        this.loadErrors = [];
+    }
+    /**
+     * Reload settings from disk, but only apply when the on-disk content is valid.
+     * Invalid edits are reported in `errors` but do not clobber the last good config.
+     *
+     * Returns true when the effective in-memory settings changed.
+     */
+    reloadFromDiskIfValid() {
+        const prevFormatted = formatSettingsJson(this.currentSettings);
+        if (!existsSync(this.settingsPath)) {
+            const next = structuredClone(DEFAULT_SETTINGS);
+            const changed = prevFormatted !== formatSettingsJson(next);
+            this.currentSettings = next;
+            this.compiledFilters = [];
+            this.loadErrors = [];
+            return changed;
+        }
+        let content;
+        try {
+            content = readFileSync(this.settingsPath, "utf8");
+        }
+        catch (err) {
+            this.loadErrors = [
+                `Failed to read local settings at ${this.settingsPath}: ${String(err?.message ?? err)}`,
+            ];
+            return false;
+        }
+        const result = this.validate(content);
+        if (!result.valid || !result.settings) {
+            this.loadErrors = result.errors;
+            return false;
+        }
+        this.currentSettings = result.settings;
+        this.compiledFilters = compileFilters(result.settings);
+        this.loadErrors = [];
+        return prevFormatted !== formatSettingsJson(this.currentSettings);
+    }
+    validate(content) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch (err) {
+            return {
+                valid: false,
+                errors: [`Invalid JSON: ${String(err?.message ?? err)}`],
+            };
+        }
+        const errors = [];
+        const settings = validateSettingsObject(parsed, errors);
+        if (!settings) {
+            return { valid: false, errors };
+        }
+        // Compile regexes during validation so users see precise errors before save.
+        for (const [i, filter] of settings.sidebar.cwdTitle.filters.entries()) {
+            try {
+                new RegExp(filter.pattern, filter.flags ?? "");
+            }
+            catch (err) {
+                errors.push(`sidebar.cwdTitle.filters[${i}].pattern is invalid regex: ${String(err?.message ?? err)}`);
+            }
+        }
+        if (errors.length > 0) {
+            return { valid: false, errors };
+        }
+        return {
+            valid: true,
+            errors: [],
+            settings,
+            formatted: formatSettingsJson(settings),
+        };
+    }
+    save(content) {
+        const result = this.validate(content);
+        if (!result.valid || !result.settings || !result.formatted) {
+            return result;
+        }
+        try {
+            mkdirSync(path.dirname(this.settingsPath), { recursive: true });
+            const tmp = `${this.settingsPath}.tmp`;
+            writeFileSync(tmp, result.formatted, "utf8");
+            renameSync(tmp, this.settingsPath);
+        }
+        catch (err) {
+            return {
+                valid: false,
+                errors: [`Failed to write settings: ${String(err?.message ?? err)}`],
+            };
+        }
+        this.currentSettings = result.settings;
+        this.compiledFilters = compileFilters(result.settings);
+        this.loadErrors = [];
+        return result;
+    }
+    /**
+     * Merge a partial settings object into the current settings.
+     * Only the provided top-level sections are merged (deep-merged one level).
+     */
+    patch(partial) {
+        const merged = structuredClone(this.currentSettings);
+        for (const key of Object.keys(partial)) {
+            if (key === "version")
+                continue; // never patch version
+            if (merged[key] && typeof merged[key] === "object" && typeof partial[key] === "object" && !Array.isArray(partial[key])) {
+                Object.assign(merged[key], partial[key]);
+            }
+            else {
+                merged[key] = partial[key];
+            }
+        }
+        const json = JSON.stringify(merged, null, 2);
+        return this.save(json);
+    }
+}
+function validateSettingsObject(value, errors) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        errors.push("Settings must be a JSON object");
+        return null;
+    }
+    if (value.version !== 1) {
+        errors.push("version must be 1");
+    }
+    const sidebar = value.sidebar;
+    if (!sidebar || typeof sidebar !== "object" || Array.isArray(sidebar)) {
+        errors.push("sidebar must be an object");
+    }
+    const cwdTitle = sidebar?.cwdTitle;
+    if (!cwdTitle || typeof cwdTitle !== "object" || Array.isArray(cwdTitle)) {
+        errors.push("sidebar.cwdTitle must be an object");
+    }
+    const filtersRaw = cwdTitle?.filters;
+    if (!Array.isArray(filtersRaw)) {
+        errors.push("sidebar.cwdTitle.filters must be an array");
+    }
+    const filters = [];
+    if (Array.isArray(filtersRaw)) {
+        filtersRaw.forEach((raw, i) => {
+            if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+                errors.push(`sidebar.cwdTitle.filters[${i}] must be an object`);
+                return;
+            }
+            if (typeof raw.pattern !== "string") {
+                errors.push(`sidebar.cwdTitle.filters[${i}].pattern must be a string`);
+            }
+            if (typeof raw.replacement !== "string") {
+                errors.push(`sidebar.cwdTitle.filters[${i}].replacement must be a string`);
+            }
+            if (raw.flags !== undefined && typeof raw.flags !== "string") {
+                errors.push(`sidebar.cwdTitle.filters[${i}].flags must be a string when provided`);
+            }
+            if (typeof raw.pattern === "string" && typeof raw.replacement === "string") {
+                filters.push({
+                    pattern: raw.pattern,
+                    replacement: raw.replacement,
+                    ...(typeof raw.flags === "string" ? { flags: raw.flags } : {}),
+                });
+            }
+        });
+    }
+    // sidebar.sessionsPerProject (optional, defaults to DEFAULT_SESSIONS_PER_PROJECT)
+    let sessionsPerProject = DEFAULT_SESSIONS_PER_PROJECT;
+    if (sidebar?.sessionsPerProject !== undefined) {
+        if (typeof sidebar.sessionsPerProject !== "number" || !Number.isInteger(sidebar.sessionsPerProject) || sidebar.sessionsPerProject < 1) {
+            errors.push("sidebar.sessionsPerProject must be a positive integer");
+        }
+        else {
+            sessionsPerProject = sidebar.sessionsPerProject;
+        }
+    }
+    // canvas section (optional, defaults to { enabled: false })
+    const canvasRaw = value.canvas;
+    let canvasEnabled = false;
+    if (canvasRaw !== undefined) {
+        if (!canvasRaw || typeof canvasRaw !== "object" || Array.isArray(canvasRaw)) {
+            errors.push("canvas must be an object");
+        }
+        else if (typeof canvasRaw.enabled !== "boolean") {
+            errors.push("canvas.enabled must be a boolean");
+        }
+        else {
+            canvasEnabled = canvasRaw.enabled;
+        }
+    }
+    // appearance section (optional, defaults to { colorTheme: "gruvbox", darkMode: "dark", showTokenUsage: true })
+    const appearanceRaw = value.appearance;
+    let colorTheme = "gruvbox";
+    let darkMode = "dark";
+    let showTokenUsage = true;
+    if (appearanceRaw !== undefined) {
+        if (!appearanceRaw || typeof appearanceRaw !== "object" || Array.isArray(appearanceRaw)) {
+            errors.push("appearance must be an object");
+        }
+        else {
+            if (appearanceRaw.colorTheme !== undefined) {
+                if (typeof appearanceRaw.colorTheme !== "string" || !VALID_COLOR_THEMES.includes(appearanceRaw.colorTheme)) {
+                    errors.push(`appearance.colorTheme must be one of: ${VALID_COLOR_THEMES.join(", ")}`);
+                }
+                else {
+                    colorTheme = appearanceRaw.colorTheme;
+                }
+            }
+            if (appearanceRaw.darkMode !== undefined) {
+                if (typeof appearanceRaw.darkMode !== "string" || !VALID_DARK_MODES.includes(appearanceRaw.darkMode)) {
+                    errors.push(`appearance.darkMode must be one of: ${VALID_DARK_MODES.join(", ")}`);
+                }
+                else {
+                    darkMode = appearanceRaw.darkMode;
+                }
+            }
+            if (appearanceRaw.showTokenUsage !== undefined) {
+                if (typeof appearanceRaw.showTokenUsage !== "boolean") {
+                    errors.push("appearance.showTokenUsage must be a boolean");
+                }
+                else {
+                    showTokenUsage = appearanceRaw.showTokenUsage;
+                }
+            }
+        }
+    }
+    // Validate toolCollapse (optional)
+    let toolCollapse;
+    if (value.toolCollapse !== undefined) {
+        const tc = value.toolCollapse;
+        if (!tc || typeof tc !== "object" || Array.isArray(tc)) {
+            errors.push("toolCollapse must be an object");
+        }
+        else if (typeof tc.keepOpen !== "number" || !Number.isFinite(tc.keepOpen) || tc.keepOpen < 0 || Math.floor(tc.keepOpen) !== tc.keepOpen) {
+            errors.push("toolCollapse.keepOpen must be a non-negative integer");
+        }
+        else {
+            toolCollapse = { keepOpen: tc.keepOpen };
+        }
+    }
+    if (errors.length > 0)
+        return null;
+    return {
+        version: 1,
+        sidebar: {
+            cwdTitle: {
+                filters,
+            },
+            sessionsPerProject,
+        },
+        canvas: {
+            enabled: canvasEnabled,
+        },
+        appearance: {
+            colorTheme,
+            darkMode,
+            showTokenUsage,
+        },
+        ...(toolCollapse ? { toolCollapse } : {}),
+    };
+}
+function compileFilters(settings) {
+    const compiled = [];
+    for (const filter of settings.sidebar.cwdTitle.filters) {
+        compiled.push({
+            re: new RegExp(filter.pattern, filter.flags ?? ""),
+            replacement: filter.replacement,
+        });
+    }
+    return compiled;
+}

package/dist/server/server/pi-launch.js

@@ -0,0 +1,10 @@
+export function resolvePiLaunch(piCli) {
+    const cli = (piCli ?? "").trim();
+    if (!cli) {
+        return { command: "pi", baseArgs: [] };
+    }
+    if (cli.endsWith(".js") || cli.endsWith(".mjs") || cli.endsWith(".cjs")) {
+        return { command: "node", baseArgs: [cli] };
+    }
+    return { command: cli, baseArgs: [] };
+}

package/dist/server/server/pi-runtime.js

@@ -0,0 +1,32 @@
+import path from "node:path";
+import { existsSync as fsExistsSync } from "node:fs";
+import { spawnSync as childSpawnSync } from "node:child_process";
+function looksLikePath(command) {
+    return command.includes("/") || command.includes(path.sep);
+}
+export function checkCommandAvailable(command, deps = {}) {
+    const existsSync = deps.existsSync ?? fsExistsSync;
+    const spawnSync = deps.spawnSync ?? childSpawnSync;
+    if (looksLikePath(command)) {
+        return existsSync(command);
+    }
+    const result = spawnSync("which", [command], {
+        stdio: "ignore",
+        env: process.env,
+    });
+    return result.status === 0;
+}
+export function isPiInstallable(command, baseArgs) {
+    return command === "pi" && baseArgs.length === 0;
+}
+export function makePiNotFoundMessage(command) {
+    return `pi command not found: '${command}'. Install pi or set PI_CLI to a working CLI path/binary.`;
+}
+export async function installPiGlobal(deps = {}) {
+    const spawnSync = deps.spawnSync ?? childSpawnSync;
+    const result = spawnSync("npm", ["install", "-g", "@mariozechner/pi-coding-agent"], {
+        stdio: "inherit",
+        env: process.env,
+    });
+    return result.status === 0;
+}

package/dist/server/server/process-pool.js

@@ -0,0 +1,254 @@
+/**
+ * CWD-aware process pool for pi RPC processes.
+ *
+ * Processes are grouped by cwd. When acquiring a process for a session,
+ * the caller provides the session's cwd and gets a process that was
+ * spawned in that directory. This ensures bash/read/edit/write tools
+ * operate in the correct project directory.
+ *
+ * Features:
+ * - Lazy spawning per-cwd with configurable pre-warming
+ * - Readiness check via get_state RPC (replaces setTimeout(500) hack)
+ * - Dead process cleanup on exit
+ * - Global process cap
+ */
+import { spawn } from "node:child_process";
+import * as readline from "node:readline";
+export class ProcessPool {
+    /** All live processes, keyed by cwd */
+    pools = new Map();
+    nextProcId = 0;
+    spawnConfig;
+    maxProcesses;
+    prewarmCount;
+    rpcTimeout;
+    onProcessExit;
+    constructor(spawnConfig, options) {
+        this.spawnConfig = spawnConfig;
+        this.maxProcesses = options?.maxProcesses ?? 6;
+        this.prewarmCount = options?.prewarmCount ?? 2;
+        this.rpcTimeout = options?.rpcTimeout ?? 30000;
+        this.onProcessExit = options?.onProcessExit;
+    }
+    /** Get the total count of live processes across all cwds */
+    get totalProcesses() {
+        let count = 0;
+        for (const procs of this.pools.values()) {
+            count += procs.filter((p) => p.process.exitCode === null).length;
+        }
+        return count;
+    }
+    /** Get all processes (for debug endpoint) */
+    getAllProcesses() {
+        const all = [];
+        for (const procs of this.pools.values()) {
+            all.push(...procs);
+        }
+        return all;
+    }
+    /**
+     * Spawn a new RPC process for the given cwd.
+     * Does not wait for readiness — call waitForReady() separately.
+     */
+    spawn(cwd) {
+        const procId = ++this.nextProcId;
+        console.log(`[pool] Spawning pi process #${procId} (cwd: ${cwd})...`);
+        // Strip NODE_ENV from the child environment so tools spawned by pi
+        // (e.g. bash) don't inherit pipane's "production" setting.
+        const { NODE_ENV: _, ...parentEnv } = process.env;
+        const baseArgs = typeof this.spawnConfig.baseArgs === "function"
+            ? this.spawnConfig.baseArgs()
+            : this.spawnConfig.baseArgs;
+        const child = spawn(this.spawnConfig.command, [
+            ...baseArgs,
+            ...(this.spawnConfig.extraArgs ?? []),
+        ], {
+            cwd,
+            env: { ...parentEnv, ...(this.spawnConfig.env ?? {}) },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        child.stderr?.on("data", (data) => {
+            process.stderr.write(`[pi#${procId}] ${data.toString()}`);
+        });
+        const rl = readline.createInterface({ input: child.stdout, terminal: false });
+        const proc = {
+            id: procId,
+            cwd,
+            process: child,
+            rl,
+            pendingRequests: new Map(),
+            requestId: 0,
+            lastResponseTime: Date.now(),
+        };
+        // Set up response handler
+        rl.on("line", (line) => {
+            let data;
+            try {
+                data = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (data.type === "response" && data.id && proc.pendingRequests.has(data.id)) {
+                const pending = proc.pendingRequests.get(data.id);
+                proc.pendingRequests.delete(data.id);
+                proc.lastResponseTime = Date.now();
+                pending.resolve(data);
+            }
+        });
+        child.on("exit", (code) => {
+            console.log(`[pool] pi#${proc.id} exited (code ${code})`);
+            // Remove from pool
+            const poolForCwd = this.pools.get(cwd);
+            if (poolForCwd) {
+                const idx = poolForCwd.indexOf(proc);
+                if (idx !== -1)
+                    poolForCwd.splice(idx, 1);
+                if (poolForCwd.length === 0)
+                    this.pools.delete(cwd);
+            }
+            // Reject any pending requests
+            for (const [, pending] of proc.pendingRequests) {
+                pending.reject(new Error(`pi process #${proc.id} exited unexpectedly (code ${code})`));
+            }
+            proc.pendingRequests.clear();
+            // Notify caller
+            this.onProcessExit?.(proc);
+        });
+        // Add to pool
+        let poolForCwd = this.pools.get(cwd);
+        if (!poolForCwd) {
+            poolForCwd = [];
+            this.pools.set(cwd, poolForCwd);
+        }
+        poolForCwd.push(proc);
+        console.log(`[pool] pi#${procId} spawned (total: ${this.totalProcesses})`);
+        return proc;
+    }
+    /**
+     * Wait for a process to be ready by sending a get_state RPC.
+     * Falls back to a timeout if the process doesn't respond.
+     */
+    async waitForReady(proc, timeoutMs = 5000) {
+        try {
+            await this.sendRpc(proc, { type: "get_state" }, timeoutMs);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get an idle process for the given cwd, or spawn one.
+     * An "idle" process is one that's alive and not in the busySet.
+     */
+    acquire(cwd, busySet) {
+        const poolForCwd = this.pools.get(cwd);
+        if (poolForCwd) {
+            const idle = poolForCwd.find((p) => p.process.exitCode === null && !busySet.has(p));
+            if (idle)
+                return idle;
+        }
+        // Check global cap
+        if (this.totalProcesses >= this.maxProcesses) {
+            return null;
+        }
+        return this.spawn(cwd);
+    }
+    /**
+     * Get any live process (idle preferred). For model queries that don't
+     * need a specific cwd.
+     */
+    getAny(busySet) {
+        // Prefer idle
+        for (const procs of this.pools.values()) {
+            const idle = procs.find((p) => p.process.exitCode === null && !busySet.has(p));
+            if (idle)
+                return idle;
+        }
+        // Fall back to any live process
+        for (const procs of this.pools.values()) {
+            const live = procs.find((p) => p.process.exitCode === null);
+            if (live)
+                return live;
+        }
+        return null;
+    }
+    /**
+     * Evict one idle process from a different cwd to free capacity.
+     * Returns the evicted process, or null if none can be evicted.
+     */
+    evictIdleDifferentCwd(targetCwd, busySet) {
+        for (const [cwd, procs] of this.pools) {
+            if (cwd === targetCwd)
+                continue;
+            const victim = procs.find((p) => p.process.exitCode === null && !busySet.has(p));
+            if (!victim)
+                continue;
+            console.log(`[pool] Evicting idle pi#${victim.id} from cwd ${cwd} to make room for ${targetCwd}`);
+            victim.process.kill("SIGTERM");
+            return victim;
+        }
+        return null;
+    }
+    /**
+     * Pre-warm the pool with processes for the given cwd.
+     */
+    /**
+     * Pre-warm the pool with processes for the given cwd.
+     * Spawns are staggered: each process must be ready (via get_state RPC)
+     * before the next one is spawned. This prevents lock contention on
+     * shared resources like auth.json during startup.
+     */
+    async prewarm(cwd) {
+        const existing = this.pools.get(cwd)?.filter((p) => p.process.exitCode === null).length ?? 0;
+        const needed = Math.min(this.prewarmCount, this.maxProcesses) - existing;
+        for (let i = 0; i < needed; i++) {
+            if (this.totalProcesses >= this.maxProcesses)
+                break;
+            const proc = this.spawn(cwd);
+            if (i < needed - 1) {
+                // Wait for this process to be ready before spawning the next one
+                await this.waitForReady(proc);
+            }
+        }
+    }
+    /**
+     * Send an RPC command to a process and wait for a response.
+     */
+    sendRpc(proc, command, timeoutMs) {
+        if (!proc.process || proc.process.exitCode !== null) {
+            return Promise.reject(new Error("RPC process is dead"));
+        }
+        const timeout = timeoutMs ?? this.rpcTimeout;
+        const id = `req_${++proc.requestId}`;
+        const fullCommand = { ...command, id };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                proc.pendingRequests.delete(id);
+                reject(new Error(`Timeout waiting for RPC response to ${command.type}`));
+            }, timeout);
+            proc.pendingRequests.set(id, {
+                resolve: (data) => {
+                    clearTimeout(timer);
+                    resolve(data);
+                },
+                reject: (err) => {
+                    clearTimeout(timer);
+                    reject(err);
+                },
+            });
+            proc.process.stdin.write(JSON.stringify(fullCommand) + "\n");
+        });
+    }
+    /**
+     * Send an RPC command and throw if it fails.
+     */
+    async sendRpcChecked(proc, command) {
+        const response = await this.sendRpc(proc, command);
+        if (!response?.success) {
+            throw new Error(response?.error || `RPC command failed: ${command.type}`);
+        }
+        return response;
+    }
+}