@pimote/pimote 0.1.0

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@pimote/pimote",
+  "version": "0.1.0",
+  "description": "Web client and embedded server for pi with multi-session browser access, streaming, and extension UI support",
+  "type": "module",
+  "license": "MIT",
+  "author": "Antoine Lennartz <alennartz@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alennartz/pimote.git"
+  },
+  "homepage": "https://github.com/alennartz/pimote#readme",
+  "bugs": "https://github.com/alennartz/pimote/issues",
+  "keywords": [
+    "pi",
+    "pimote",
+    "coding-agent",
+    "browser",
+    "pwa",
+    "remote"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "pimote": "bin/pimote.js"
+  },
+  "files": [
+    "bin/pimote.js",
+    "client/build/**",
+    "server/dist/**/*.js",
+    "scripts/postinstall-patches.mjs",
+    "patches/@mariozechner+pi-coding-agent+0.65.0.patch",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "workspaces": [
+    "shared",
+    "server",
+    "client",
+    "packages/panels"
+  ],
+  "scripts": {
+    "build": "npm run build --workspace=shared && npm run build --workspace=@pimote/server && npm run build --workspace=client",
+    "start": "node ./bin/pimote.js start",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint .",
+    "check": "npm run check --workspace=client && tsc --noEmit -p server/tsconfig.json && tsc --noEmit -p shared/tsconfig.json",
+    "prepare": "husky",
+    "postinstall": "node ./scripts/postinstall-patches.mjs",
+    "prepack": "npm run build",
+    "pack:dry-run": "npm pack --dry-run"
+  },
+  "lint-staged": {
+    "*.{ts,js,svelte,css,html,json,md,yaml}": "prettier --write",
+    "*.{ts,js,svelte}": "eslint --no-fix"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.2.0",
+    "eslint-plugin-svelte": "^3.17.0",
+    "globals": "^17.4.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "prettier": "^3.8.1",
+    "prettier-plugin-svelte": "^3.5.1",
+    "prettier-plugin-tailwindcss": "^0.7.2",
+    "typescript-eslint": "^8.58.0"
+  },
+  "dependencies": {
+    "@fontsource-variable/jetbrains-mono": "^5.2.8",
+    "@mariozechner/pi-coding-agent": "0.65.0",
+    "patch-package": "^8.0.1",
+    "web-push": "^3.6.7",
+    "ws": "^8.20.0"
+  }
+}

package/patches/@mariozechner+pi-coding-agent+0.65.0.patch

@@ -0,0 +1,24 @@
+diff --git a/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session-runtime.js b/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session-runtime.js
+index 9ab786e..6f89829 100644
+--- a/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session-runtime.js
++++ b/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session-runtime.js
+@@ -74,9 +74,6 @@ export class AgentSessionRuntime {
+         this.session.dispose();
+     }
+     apply(result) {
+-        if (process.cwd() !== result.services.cwd) {
+-            process.chdir(result.services.cwd);
+-        }
+         this._session = result.session;
+         this._services = result.services;
+         this._diagnostics = result.diagnostics;
+@@ -223,9 +220,6 @@ export class AgentSessionRuntime {
+  */
+ export async function createAgentSessionRuntime(createRuntime, options) {
+     const result = await createRuntime(options);
+-    if (process.cwd() !== result.services.cwd) {
+-        process.chdir(result.services.cwd);
+-    }
+     return new AgentSessionRuntime(result.session, result.services, createRuntime, result.diagnostics, result.modelFallbackMessage);
+ }
+ export { createAgentSessionFromServices, createAgentSessionServices, } from "./agent-session-services.js";

package/scripts/postinstall-patches.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import { readdir, stat } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
+const pathParts = packageRoot.split('/node_modules/');
+const installRoot = pathParts.length > 1 ? pathParts[0] : packageRoot;
+const patchDir = join(packageRoot, 'patches');
+const patchPackageEntrypoint = join(installRoot, 'node_modules', 'patch-package', 'index.js');
+
+async function hasPatchFiles(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries.some((entry) => entry.isFile() && entry.name.endsWith('.patch'));
+  } catch {
+    return false;
+  }
+}
+
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function main() {
+  if (!(await hasPatchFiles(patchDir))) {
+    return;
+  }
+
+  if (!(await exists(patchPackageEntrypoint))) {
+    throw new Error(`[pimote] Could not find patch-package at ${patchPackageEntrypoint}`);
+  }
+
+  const patchDirArg = relative(installRoot, patchDir) || patchDir;
+  const result = spawnSync(process.execPath, [patchPackageEntrypoint, '--patch-dir', patchDirArg], {
+    cwd: installRoot,
+    stdio: 'inherit',
+  });
+
+  if (result.status !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/server/dist/cli.js

@@ -0,0 +1,347 @@
+import { access, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { createInterface } from 'node:readline/promises';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { stdin as input, stdout as output } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { CONFIG_PATH } from './config.js';
+import { PIMOTE_STATE_DIR } from './paths.js';
+import { main as startPimote } from './index.js';
+const ROOT_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+export async function getVersion() {
+    const raw = await readFile(join(ROOT_DIR, 'package.json'), 'utf-8');
+    const pkg = JSON.parse(raw);
+    return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+}
+export function printHelp() {
+    console.log(`pimote — browser UI for pi
+
+Usage:
+  pimote [--port <port>]             Start Pimote (runs first-time setup if needed)
+  pimote start [--port <port>]       Start Pimote using your existing config
+  pimote init [options]              Create or update Pimote config
+  pimote help                        Show this help
+  pimote version                     Show the installed version
+
+Options:
+  -p, --port <port>                  Override the server port for this run, or set it during init
+  -r, --root <path>                  Add a project root during init (repeatable)
+  -h, --help                         Show this help
+  -v, --version                      Show the installed version
+
+Environment:
+  PORT                               Override the configured server port
+
+Examples:
+  pimote
+  pimote --port 3001
+  pimote init --root ~/projects --root ~/work --port 3001
+`);
+}
+export function expandHomePath(value) {
+    if (value === '~')
+        return homedir();
+    if (value.startsWith('~/'))
+        return join(homedir(), value.slice(2));
+    return value;
+}
+export async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(path) {
+    try {
+        const info = await stat(path);
+        return info.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function looksLikeProjectDirectory(path) {
+    return (await pathExists(join(path, '.git'))) || (await pathExists(join(path, 'package.json')));
+}
+export function parsePort(raw) {
+    const text = String(raw).trim();
+    if (!/^\d+$/.test(text)) {
+        throw new Error(`Invalid port: ${raw}`);
+    }
+    const port = Number.parseInt(text, 10);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`Invalid port: ${raw}`);
+    }
+    return port;
+}
+export async function normalizeRoots(values) {
+    const parts = values
+        .flatMap((value) => String(value).split(','))
+        .map((value) => value.trim())
+        .filter(Boolean);
+    if (parts.length === 0) {
+        throw new Error('At least one project root is required.');
+    }
+    const uniqueRoots = [];
+    const seen = new Set();
+    for (const part of parts) {
+        const resolved = resolve(expandHomePath(part));
+        if (!(await isDirectory(resolved))) {
+            throw new Error(`Project root does not exist or is not a directory: ${part}`);
+        }
+        if (!seen.has(resolved)) {
+            seen.add(resolved);
+            uniqueRoots.push(resolved);
+        }
+    }
+    return uniqueRoots;
+}
+async function suggestDefaultRoot() {
+    const cwd = process.cwd();
+    if (await looksLikeProjectDirectory(cwd)) {
+        return dirname(cwd);
+    }
+    const candidates = [join(homedir(), 'projects'), join(homedir(), 'work'), join(homedir(), 'repos')];
+    for (const candidate of candidates) {
+        if (await isDirectory(candidate))
+            return candidate;
+    }
+    return cwd;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+async function readExistingConfigObject(configPath) {
+    try {
+        const raw = await readFile(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!isPlainObject(parsed)) {
+            return {
+                exists: true,
+                data: {},
+                warning: `[pimote] Existing config at ${configPath} is not a JSON object. It will be replaced.`,
+            };
+        }
+        return { exists: true, data: parsed };
+    }
+    catch (err) {
+        if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+            return { exists: false, data: {} };
+        }
+        return {
+            exists: true,
+            data: {},
+            warning: `[pimote] Existing config at ${configPath} could not be read. It will be replaced.`,
+        };
+    }
+}
+function buildConfigPayload(existingConfig, roots, port) {
+    return {
+        ...existingConfig,
+        roots,
+        port,
+    };
+}
+async function writeConfig(configPath, config) {
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+function printSetupIntro(configPath, stateDir, isUpdate) {
+    console.log(isUpdate ? '[pimote] Updating Pimote setup.' : '[pimote] Welcome to Pimote.');
+    console.log('');
+    console.log('Pimote runs a local web app for pi. It scans the project roots you choose,');
+    console.log('starts a local server, and opens your pi sessions in the browser.');
+    console.log('');
+    console.log('Before you start chatting, make sure pi has at least one working provider/model');
+    console.log('configured, either through API keys or your existing pi login setup.');
+    console.log('');
+    console.log(`Config file: ${configPath}`);
+    console.log(`State dir:   ${stateDir}`);
+    console.log('');
+}
+async function promptWithDefault(rl, label, defaultValue) {
+    const suffix = defaultValue ? ` [${defaultValue}]` : '';
+    const answer = await rl.question(`${label}${suffix}: `);
+    return answer.trim() || defaultValue;
+}
+async function promptForRoots(rl, defaultRoots) {
+    while (true) {
+        const answer = await promptWithDefault(rl, 'Project roots (comma-separated parent directories to scan for repos)', defaultRoots.join(', '));
+        try {
+            return await normalizeRoots([answer]);
+        }
+        catch (err) {
+            console.error(`[pimote] ${err instanceof Error ? err.message : err}`);
+            console.error('[pimote] Example: ~/projects, ~/work');
+        }
+    }
+}
+async function promptForPort(rl, defaultPort) {
+    while (true) {
+        const answer = await promptWithDefault(rl, 'Port', String(defaultPort));
+        try {
+            return parsePort(answer);
+        }
+        catch (err) {
+            console.error(`[pimote] ${err instanceof Error ? err.message : err}`);
+            console.error('[pimote] Enter a number between 1 and 65535.');
+        }
+    }
+}
+async function runInteractiveInit(options) {
+    const { configPath, stateDir, existingConfig, cliPort, cliRoots } = options;
+    const existingRoots = Array.isArray(existingConfig.roots) && existingConfig.roots.every((value) => typeof value === 'string') ? existingConfig.roots : [];
+    const defaultRoots = cliRoots.length > 0 ? await normalizeRoots(cliRoots) : existingRoots.length > 0 ? existingRoots : [await suggestDefaultRoot()];
+    const defaultPort = cliPort ?? (typeof existingConfig.port === 'number' ? existingConfig.port : 3000);
+    printSetupIntro(configPath, stateDir, Object.keys(existingConfig).length > 0);
+    console.log('Tip: roots should be parent directories like ~/projects, not individual repos.');
+    console.log('Pimote scans each root one level deep and picks folders containing .git or package.json.');
+    console.log('');
+    const rl = createInterface({ input, output });
+    try {
+        const roots = cliRoots.length > 0 ? defaultRoots : await promptForRoots(rl, defaultRoots);
+        const port = cliPort ?? (await promptForPort(rl, defaultPort));
+        return { roots, port };
+    }
+    finally {
+        rl.close();
+    }
+}
+async function resolveInitConfig(options) {
+    const { interactive, existingConfig, configPath, stateDir, cliPort, cliRoots } = options;
+    if (cliRoots.length > 0 && !interactive) {
+        return {
+            roots: await normalizeRoots(cliRoots),
+            port: cliPort ?? (typeof existingConfig.port === 'number' ? existingConfig.port : 3000),
+        };
+    }
+    if (!interactive) {
+        throw new Error(`No interactive terminal detected. Run \`pimote init --root /path/to/projects [--port 3000]\` or create ${configPath} manually.`);
+    }
+    return runInteractiveInit({
+        interactive,
+        existingConfig,
+        configPath,
+        stateDir,
+        cliPort,
+        cliRoots,
+    });
+}
+export async function initializeConfig(options) {
+    const existing = await readExistingConfigObject(CONFIG_PATH);
+    if (existing.warning) {
+        console.warn(existing.warning);
+    }
+    const desired = await resolveInitConfig({
+        interactive: Boolean(input.isTTY && output.isTTY),
+        existingConfig: existing.data,
+        configPath: CONFIG_PATH,
+        stateDir: PIMOTE_STATE_DIR,
+        cliPort: options.cliPort,
+        cliRoots: options.cliRoots,
+    });
+    const config = buildConfigPayload(existing.data, desired.roots, desired.port);
+    await writeConfig(CONFIG_PATH, config);
+    console.log(`[pimote] Wrote config to ${CONFIG_PATH}`);
+    console.log(`[pimote] Pimote will scan these roots:`);
+    for (const root of desired.roots) {
+        console.log(`  - ${root}`);
+    }
+    console.log(`[pimote] Pimote will listen on http://localhost:${desired.port}`);
+    console.log(`[pimote] Runtime state will be stored in ${PIMOTE_STATE_DIR}`);
+    if (options.command === 'init') {
+        console.log('[pimote] Next step: run `pimote` and open the printed URL in your browser.');
+    }
+    return { configPath: CONFIG_PATH, created: !existing.exists, port: desired.port };
+}
+export function parseArgs(argv) {
+    const commands = new Set(['start', 'init', 'help', 'version']);
+    let command = 'start';
+    let index = 0;
+    if (argv[0] === '--help' || argv[0] === '-h') {
+        return { command: 'help', port: undefined, roots: [] };
+    }
+    if (argv[0] === '--version' || argv[0] === '-v') {
+        return { command: 'version', port: undefined, roots: [] };
+    }
+    if (argv[0] && !argv[0].startsWith('-')) {
+        if (!commands.has(argv[0])) {
+            return { command: 'start', roots: [], error: `Unknown command: ${argv[0]}` };
+        }
+        command = argv[0];
+        index = 1;
+    }
+    let port;
+    const roots = [];
+    while (index < argv.length) {
+        const arg = argv[index];
+        if (arg === '--help' || arg === '-h') {
+            return { command: 'help', port, roots };
+        }
+        if (arg === '--version' || arg === '-v') {
+            return { command: 'version', port, roots };
+        }
+        if (arg === '--port' || arg === '-p') {
+            const value = argv[index + 1];
+            if (!value)
+                return { command, port, roots, error: 'Missing value for --port' };
+            try {
+                port = parsePort(value);
+            }
+            catch (err) {
+                return { command, port, roots, error: err instanceof Error ? err.message : String(err) };
+            }
+            index += 2;
+            continue;
+        }
+        if (arg === '--root' || arg === '-r') {
+            const value = argv[index + 1];
+            if (!value)
+                return { command, port, roots, error: 'Missing value for --root' };
+            roots.push(value);
+            index += 2;
+            continue;
+        }
+        return { command, port, roots, error: `Unknown option: ${arg}` };
+    }
+    return { command, port, roots };
+}
+export async function ensureConfigForStart(parsed) {
+    if (await pathExists(CONFIG_PATH)) {
+        return { created: false, configPath: CONFIG_PATH };
+    }
+    console.log(`[pimote] No config found at ${CONFIG_PATH}.`);
+    console.log('');
+    const result = await initializeConfig({ command: 'start', cliPort: parsed.port, cliRoots: parsed.roots });
+    console.log('');
+    console.log('[pimote] Starting server...');
+    return result;
+}
+export async function startServer(parsed) {
+    await ensureConfigForStart(parsed);
+    await startPimote({ portOverride: parsed.port });
+}
+export async function runCli(argv = process.argv.slice(2)) {
+    const parsed = parseArgs(argv);
+    if (parsed.error) {
+        console.error(`[pimote] ${parsed.error}`);
+        console.error('Run `pimote help` for usage.');
+        process.exit(1);
+    }
+    if (parsed.command === 'help') {
+        printHelp();
+        return;
+    }
+    if (parsed.command === 'version') {
+        console.log(await getVersion());
+        return;
+    }
+    if (parsed.command === 'init') {
+        await initializeConfig({ command: 'init', cliPort: parsed.port, cliRoots: parsed.roots });
+        return;
+    }
+    await startServer(parsed);
+}

package/server/dist/config.js

@@ -0,0 +1,78 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { PIMOTE_CONFIG_PATH } from './paths.js';
+export const CONFIG_PATH = PIMOTE_CONFIG_PATH;
+const DEFAULTS = {
+    idleTimeout: 1_800_000, // 30 minutes
+    bufferSize: 1000,
+    port: 3000,
+};
+export async function loadConfig() {
+    let raw;
+    try {
+        raw = await readFile(CONFIG_PATH, 'utf-8');
+    }
+    catch (err) {
+        if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+            throw new Error(`Config file not found at ${CONFIG_PATH}\n\n` +
+                `Create it with at least a "roots" array, e.g.:\n\n` +
+                `  {\n` +
+                `    "roots": ["/path/to/your/project"]\n` +
+                `  }\n\n` +
+                `Optional fields: port (default ${DEFAULTS.port}), ` +
+                `idleTimeout (default ${DEFAULTS.idleTimeout}ms), ` +
+                `bufferSize (default ${DEFAULTS.bufferSize})`, { cause: err });
+        }
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Failed to parse ${CONFIG_PATH} as JSON`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Config at ${CONFIG_PATH} must be a JSON object`);
+    }
+    const obj = parsed;
+    // Validate roots
+    if (!Array.isArray(obj.roots) || obj.roots.length === 0 || !obj.roots.every((r) => typeof r === 'string')) {
+        throw new Error(`Config "roots" must be a non-empty array of strings in ${CONFIG_PATH}`);
+    }
+    return {
+        roots: obj.roots,
+        idleTimeout: typeof obj.idleTimeout === 'number' ? obj.idleTimeout : DEFAULTS.idleTimeout,
+        bufferSize: typeof obj.bufferSize === 'number' ? obj.bufferSize : DEFAULTS.bufferSize,
+        port: typeof obj.port === 'number' ? obj.port : DEFAULTS.port,
+        defaultProvider: typeof obj.defaultProvider === 'string' ? obj.defaultProvider : undefined,
+        defaultModel: typeof obj.defaultModel === 'string' ? obj.defaultModel : undefined,
+        defaultThinkingLevel: typeof obj.defaultThinkingLevel === 'string' ? obj.defaultThinkingLevel : undefined,
+        vapidPublicKey: typeof obj.vapidPublicKey === 'string' ? obj.vapidPublicKey : undefined,
+        vapidPrivateKey: typeof obj.vapidPrivateKey === 'string' ? obj.vapidPrivateKey : undefined,
+        vapidEmail: typeof obj.vapidEmail === 'string' ? obj.vapidEmail : undefined,
+    };
+}
+export async function ensureVapidKeys(config) {
+    if (config.vapidPublicKey && config.vapidPrivateKey) {
+        return config;
+    }
+    const webpush = await import('web-push');
+    const keys = webpush.default.generateVAPIDKeys();
+    config.vapidPublicKey = keys.publicKey;
+    config.vapidPrivateKey = keys.privateKey;
+    // Read existing file to preserve all fields, then merge in new keys
+    let existing = {};
+    try {
+        const raw = await readFile(CONFIG_PATH, 'utf-8');
+        existing = JSON.parse(raw);
+    }
+    catch {
+        // If file doesn't exist or can't be parsed, start fresh
+    }
+    existing.vapidPublicKey = keys.publicKey;
+    existing.vapidPrivateKey = keys.privateKey;
+    await mkdir(dirname(CONFIG_PATH), { recursive: true });
+    await writeFile(CONFIG_PATH, JSON.stringify(existing, null, 2) + '\n', 'utf-8');
+    return config;
+}