@getpaseo/server 0.1.88 → 0.1.90

package/dist/server/utils/worktree.js

@@ -2,7 +2,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { existsSync, mkdirSync, realpathSync, rmSync, statSync } from "fs";
 import { copyFile, rm, stat } from "fs/promises";
-import { join, basename, dirname, resolve, sep } from "path";
+import { join, basename, dirname, isAbsolute, resolve, sep } from "path";
 import net from "node:net";
 import { createHash } from "node:crypto";
 import stripAnsi from "strip-ansi";
@@ -17,6 +17,7 @@ import { resolvePaseoHome } from "../server/paseo-home.js";
 import { createExternalProcessEnv } from "../server/paseo-env.js";
 import { parseGitRevParsePath, resolveGitRevParsePath } from "./git-rev-parse-path.js";
 import { validateBranchSlug } from "@getpaseo/protocol/branch-slug";
+import { expandTilde } from "./path.js";
 export { slugify, validateBranchSlug } from "@getpaseo/protocol/branch-slug";
 const execFileAsync = promisify(execFile);
 const READ_ONLY_GIT_ENV = {
@@ -529,14 +530,26 @@ export async function deriveWorktreeProjectHash(cwd) {
         return deriveShortAlphanumericHash(normalizePathForOwnership(cwd));
     }
 }
-export async function getPaseoWorktreesRoot(cwd, paseoHome) {
-    const home = paseoHome ? resolve(paseoHome) : resolvePaseoHome();
+export function resolvePaseoWorktreesBaseRoot(options) {
+    if (options?.worktreesRoot) {
+        const expandedRoot = expandTilde(options.worktreesRoot);
+        if (isAbsolute(expandedRoot)) {
+            return resolve(expandedRoot);
+        }
+        const home = options.paseoHome ? resolve(options.paseoHome) : resolvePaseoHome();
+        return resolve(home, expandedRoot);
+    }
+    const home = options?.paseoHome ? resolve(options.paseoHome) : resolvePaseoHome();
+    return join(home, "worktrees");
+}
+export async function getPaseoWorktreesRoot(cwd, paseoHome, worktreesRoot) {
+    const baseRoot = resolvePaseoWorktreesBaseRoot({ paseoHome, worktreesRoot });
     const projectHash = await deriveWorktreeProjectHash(cwd);
-    return join(home, "worktrees", projectHash);
+    return join(baseRoot, projectHash);
 }
-export async function computeWorktreePath(cwd, slug, paseoHome) {
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
-    return join(worktreesRoot, slug);
+export async function computeWorktreePath(cwd, slug, paseoHome, worktreesRoot) {
+    const projectWorktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome, worktreesRoot);
+    return join(projectWorktreesRoot, slug);
 }
 function normalizePathForOwnership(input) {
     try {
@@ -565,9 +578,9 @@ export async function isPaseoOwnedWorktreeCwd(cwd, options) {
     catch {
         // ignore
     }
-    const paseoHome = options?.paseoHome ? resolve(options.paseoHome) : resolvePaseoHome();
-    const paseoWorktreesPrefix = normalizePathForOwnership(join(paseoHome, "worktrees")) + sep;
-    // Ownership is defined by the path living under $PASEO_HOME/worktrees/<hash>/<slug>[/...].
+    const worktreesBaseRoot = resolvePaseoWorktreesBaseRoot(options);
+    const paseoWorktreesPrefix = normalizePathForOwnership(worktreesBaseRoot) + sep;
+    // Ownership is defined by the path living under <worktrees-root>/<hash>/<slug>[/...].
     // The <hash>/<slug> prefix is Paseo-private — nothing else writes there — so the
     // path shape alone is sufficient proof of ownership, even when git has already
     // forgotten about the worktree.
@@ -587,7 +600,7 @@ export async function isPaseoOwnedWorktreeCwd(cwd, options) {
             worktreePath: resolvedCwd,
         };
     }
-    const worktreesRoot = join(paseoHome, "worktrees", parts[0]);
+    const worktreesRoot = join(worktreesBaseRoot, parts[0]);
     return {
         allowed: true,
         ...(repoRoot !== undefined ? { repoRoot } : {}),
@@ -639,22 +652,23 @@ function resolveWorktreeCreatedAtIso(worktreePath) {
         return new Date(0).toISOString();
     }
 }
-export async function listPaseoWorktrees({ cwd, paseoHome, }) {
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
+export async function listPaseoWorktrees({ cwd, paseoHome, worktreesRoot, }) {
+    const projectWorktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome, worktreesRoot);
     const { stdout } = await runGitCommand(["worktree", "list", "--porcelain"], {
         cwd,
         envOverlay: READ_ONLY_GIT_ENV,
     });
-    const rootPrefix = normalizePathForOwnership(worktreesRoot) + sep;
+    const rootPrefix = normalizePathForOwnership(projectWorktreesRoot) + sep;
     return parseWorktreeList(stdout)
         .map((entry) => Object.assign({}, entry, { path: normalizePathForOwnership(entry.path) }))
         .filter((entry) => entry.path.startsWith(rootPrefix))
         .map((entry) => Object.assign({}, entry, { createdAt: resolveWorktreeCreatedAtIso(entry.path) }));
 }
-export async function resolveExistingWorktreeForSlug({ slug, repoRoot, paseoHome, }) {
+export async function resolveExistingWorktreeForSlug({ slug, repoRoot, paseoHome, worktreesRoot, }) {
     const worktrees = await listPaseoWorktrees({
         cwd: repoRoot,
         paseoHome,
+        worktreesRoot,
     });
     const slugSuffix = `${sep}${slug}`;
     const existingWorktree = worktrees.find((worktree) => worktree.path.endsWith(slugSuffix));
@@ -682,7 +696,7 @@ export async function resolvePaseoWorktreeRootForCwd(cwd, options) {
     catch {
         return null;
     }
-    const worktreesRoot = await getPaseoWorktreesRoot(cwd, options?.paseoHome);
+    const worktreesRoot = await getPaseoWorktreesRoot(cwd, options?.paseoHome, options?.worktreesRoot);
     const resolvedRoot = normalizePathForOwnership(worktreesRoot) + sep;
     let worktreeRoot = null;
     try {
@@ -705,6 +719,7 @@ export async function resolvePaseoWorktreeRootForCwd(cwd, options) {
     const knownWorktrees = await listPaseoWorktrees({
         cwd,
         paseoHome: options?.paseoHome,
+        worktreesRoot: options?.worktreesRoot,
     });
     const match = knownWorktrees.find((entry) => entry.path === resolvedWorktreeRoot);
     if (!match) {
@@ -716,7 +731,7 @@ export async function resolvePaseoWorktreeRootForCwd(cwd, options) {
         worktreePath: match.path,
     };
 }
-export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, worktreesRoot, paseoHome, }) {
+export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, worktreesRoot, paseoHome, worktreesBaseRoot, }) {
     if (!worktreePath && !worktreeSlug) {
         throw new Error("worktreePath or worktreeSlug is required");
     }
@@ -728,7 +743,7 @@ export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, wor
         resolvedWorktreesRoot = worktreesRoot;
     }
     else if (cwd) {
-        resolvedWorktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome);
+        resolvedWorktreesRoot = await getPaseoWorktreesRoot(cwd, paseoHome, worktreesBaseRoot);
     }
     else {
         throw new Error("cwd or worktreesRoot is required to delete a Paseo worktree");
@@ -736,8 +751,10 @@ export async function deletePaseoWorktree({ cwd, worktreePath, worktreeSlug, wor
     const resolvedRoot = normalizePathForOwnership(resolvedWorktreesRoot) + sep;
     const requestedPath = worktreePath ?? join(resolvedWorktreesRoot, worktreeSlug);
     const resolvedRequested = normalizePathForOwnership(requestedPath);
-    const resolvedWorktree = (await resolvePaseoWorktreeRootForCwd(requestedPath, { paseoHome }))?.worktreePath ??
-        resolvedRequested;
+    const resolvedWorktree = (await resolvePaseoWorktreeRootForCwd(requestedPath, {
+        paseoHome,
+        worktreesRoot: worktreesBaseRoot,
+    }))?.worktreePath ?? resolvedRequested;
     if (!resolvedWorktree.startsWith(resolvedRoot)) {
         throw new Error("Refusing to delete non-Paseo worktree");
     }
@@ -812,9 +829,9 @@ async function removeDirectoryWithRetries(path) {
 /**
  * Create a git worktree with proper naming conventions
  */
-export const createWorktree = async ({ cwd, source, worktreeSlug, runSetup, paseoHome, }) => {
+export const createWorktree = async ({ cwd, source, worktreeSlug, runSetup, paseoHome, worktreesRoot, }) => {
     const sourcePlan = await resolveWorktreeSourcePlan({ cwd, source, desiredSlug: worktreeSlug });
-    let worktreePath = join(await getPaseoWorktreesRoot(cwd, paseoHome), worktreeSlug);
+    let worktreePath = join(await getPaseoWorktreesRoot(cwd, paseoHome, worktreesRoot), worktreeSlug);
     mkdirSync(dirname(worktreePath), { recursive: true });
     // Also handle worktree path collision
     let finalWorktreePath = worktreePath;

package/dist/src/server/persisted-config.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { z } from "zod";
 import { AgentProviderRuntimeSettingsMapSchema, migrateProviderSettings, ProviderOverridesSchema, } from "./agent/provider-launch-config.js";
-import { ensurePrivateFile, writePrivateFileSync } from "./private-files.js";
+import { ensurePrivateFile, writePrivateFileAtomicSync } from "./private-files.js";
 export const LogLevelSchema = z.enum(["trace", "debug", "info", "warn", "error", "fatal"]);
 export const LogFormatSchema = z.enum(["pretty", "json"]);
 const LogConfigSchema = z
@@ -49,6 +49,11 @@ const ProvidersSchema = z
     local: LocalSpeechProviderSchema.optional(),
 })
     .strict();
+const WorktreesConfigSchema = z
+    .object({
+    root: z.string().min(1).optional(),
+})
+    .strict();
 const BcryptHashSchema = z.string().regex(/^\$2[aby]\$\d{2}\$[./A-Za-z0-9]{53}$/, {
     message: "Expected a bcrypt hash",
 });
@@ -197,6 +202,17 @@ export const PersistedConfigSchema = z
         })
             .strict()
             .optional(),
+        serviceProxy: z
+            .object({
+            // COMPAT(serviceProxyEnabled): added 2026-06-02, remove after 2026-12-02.
+            // Parsed only to suppress optional public/listen layers for old configs;
+            // localhost service proxying remains always enabled.
+            enabled: z.boolean().optional(),
+            listen: z.string().optional(),
+            publicBaseUrl: z.string().url().optional(),
+        })
+            .strict()
+            .optional(),
         auth: DaemonAuthSchema.optional(),
     })
         .strict()
@@ -212,6 +228,7 @@ export const PersistedConfigSchema = z
         .strict()
         .optional(),
     providers: ProvidersSchema.optional(),
+    worktrees: WorktreesConfigSchema.optional(),
     agents: z
         .object({
         providers: z.preprocess(normalizeAgentProviders, ProviderOverridesSchema).optional(),
@@ -279,7 +296,7 @@ export function loadPersistedConfig(paseoHome, logger) {
     const configPath = getConfigPath(paseoHome);
     if (!existsSync(configPath)) {
         try {
-            writePrivateFileSync(configPath, JSON.stringify(DEFAULT_PERSISTED_CONFIG, null, 2) + "\n");
+            writePrivateFileAtomicSync(configPath, JSON.stringify(DEFAULT_PERSISTED_CONFIG, null, 2) + "\n");
             log?.info(`Initialized config file at ${configPath}`);
         }
         catch (err) {
@@ -330,7 +347,7 @@ export function savePersistedConfig(paseoHome, config, logger) {
         throw new Error(`[Config] Invalid config to save:\n${issues}`);
     }
     try {
-        writePrivateFileSync(configPath, JSON.stringify(result.data, null, 2) + "\n");
+        writePrivateFileAtomicSync(configPath, JSON.stringify(result.data, null, 2) + "\n");
         log?.info(`Saved to ${configPath}`);
     }
     catch (err) {

package/dist/src/server/private-files.js

@@ -21,11 +21,6 @@ export function ensurePrivateDirectory(directoryPath) {
 export function ensurePrivateFile(filePath) {
     chmodBestEffort(filePath, PRIVATE_FILE_MODE);
 }
-export function writePrivateFileSync(filePath, data) {
-    ensurePrivateDirectory(path.dirname(filePath));
-    writeFileSync(filePath, data, { mode: PRIVATE_FILE_MODE });
-    ensurePrivateFile(filePath);
-}
 export function writePrivateFileAtomicSync(filePath, data) {
     ensurePrivateDirectory(path.dirname(filePath));
     const tmpPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/server",
-  "version": "0.1.88",
+  "version": "0.1.90",
   "description": "Paseo backend server",
   "files": [
     "dist/server",
@@ -30,10 +30,12 @@
   "scripts": {
     "dev": "cross-env PASEO_NODE_ENV=development node --import tsx scripts/dev-runner.ts",
     "dev:tsx": "cross-env PASEO_NODE_ENV=development tsx watch --ignore '**/*.timestamp-*' scripts/dev-runner.ts",
-    "build": "node -e \"require('node:fs').rmSync('dist',{ recursive: true, force: true })\" && npm run build:lib && npm run build:scripts",
+    "clean": "node ../../scripts/clean-package-dist.mjs",
+    "build": "npm run build:lib && npm run build:scripts",
+    "build:clean": "npm run clean && npm run build",
     "build:lib": "tsc -p tsconfig.server.json --incremental false && node -e \"const fs=require('node:fs'); fs.mkdirSync('dist/server/server/speech/providers/local/sherpa/assets',{recursive:true}); fs.copyFileSync('src/server/speech/providers/local/sherpa/assets/silero_vad.onnx','dist/server/server/speech/providers/local/sherpa/assets/silero_vad.onnx'); fs.cpSync('src/terminal/shell-integration','dist/server/terminal/shell-integration',{recursive:true}); fs.cpSync('src/terminal/shell-integration','dist/src/terminal/shell-integration',{recursive:true}); fs.copyFileSync('src/terminal/terminal-ts-loader.mjs','dist/server/terminal/terminal-ts-loader.mjs');\"",
     "build:scripts": "tsc -p tsconfig.scripts.json --incremental false && node -e \"const fs=require('node:fs'); fs.mkdirSync('dist/scripts',{recursive:true}); fs.copyFileSync('scripts/mcp-stdio-socket-bridge-cli.mjs','dist/scripts/mcp-stdio-socket-bridge-cli.mjs');\"",
-    "prepack": "npm run build",
+    "prepack": "npm run build:clean",
     "start": "node dist/scripts/supervisor-entrypoint.js",
     "typecheck": "tsgo -p tsconfig.server.typecheck.json --noEmit",
     "generate:config-schema": "tsx scripts/generate-config-schema.ts",
@@ -57,10 +59,10 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.17.1",
     "@anthropic-ai/claude-agent-sdk": "^0.2.133",
-    "@getpaseo/client": "0.1.88",
-    "@getpaseo/highlight": "0.1.88",
-    "@getpaseo/protocol": "0.1.88",
-    "@getpaseo/relay": "0.1.88",
+    "@getpaseo/client": "0.1.90",
+    "@getpaseo/highlight": "0.1.90",
+    "@getpaseo/protocol": "0.1.90",
+    "@getpaseo/relay": "0.1.90",
     "@isaacs/ttlcache": "^2.1.4",
     "@modelcontextprotocol/sdk": "^1.20.1",
     "@opencode-ai/sdk": "1.14.46",

package/dist/server/server/editor-targets.d.ts

@@ -1,18 +0,0 @@
-import { existsSync } from "node:fs";
-import type { EditorTargetDescriptorPayload, EditorTargetId } from "@getpaseo/protocol/messages";
-import { spawnProcess } from "../utils/spawn.js";
-interface ListAvailableEditorTargetsDependencies {
-    platform?: NodeJS.Platform;
-    findExecutable?: (command: string) => string | null | Promise<string | null>;
-}
-type OpenInEditorTargetDependencies = ListAvailableEditorTargetsDependencies & {
-    existsSync?: typeof existsSync;
-    spawn?: typeof spawnProcess;
-};
-export declare function listAvailableEditorTargets(dependencies?: ListAvailableEditorTargetsDependencies): Promise<EditorTargetDescriptorPayload[]>;
-export declare function openInEditorTarget(input: {
-    editorId: EditorTargetId;
-    path: string;
-}, dependencies?: OpenInEditorTargetDependencies): Promise<void>;
-export {};
-//# sourceMappingURL=editor-targets.d.ts.map

package/dist/server/server/editor-targets.js

@@ -1,109 +0,0 @@
-import { existsSync } from "node:fs";
-import { posix, win32 } from "node:path";
-import { createExternalProcessEnv } from "./paseo-env.js";
-import { findExecutable } from "../utils/executable.js";
-import { spawnProcess } from "../utils/spawn.js";
-const EDITOR_TARGETS = [
-    { id: "cursor", label: "Cursor", command: "cursor" },
-    { id: "vscode", label: "VS Code", command: "code" },
-    { id: "webstorm", label: "WebStorm", command: "webstorm" },
-    { id: "zed", label: "Zed", command: "zed" },
-    { id: "finder", label: "Finder", command: "open", platforms: ["darwin"] },
-    { id: "explorer", label: "Explorer", command: "explorer", platforms: ["win32"] },
-    {
-        id: "file-manager",
-        label: "File Manager",
-        command: "xdg-open",
-        excludedPlatforms: ["darwin", "win32"],
-    },
-];
-function isAbsolutePath(value) {
-    return posix.isAbsolute(value) || win32.isAbsolute(value);
-}
-function isTargetSupportedOnPlatform(target, platform) {
-    if (target.platforms && !target.platforms.includes(platform)) {
-        return false;
-    }
-    if (target.excludedPlatforms?.includes(platform)) {
-        return false;
-    }
-    return true;
-}
-function resolveEditorTargetDefinition(editorId) {
-    const target = EDITOR_TARGETS.find((entry) => entry.id === editorId);
-    if (!target) {
-        throw new Error(`Unknown editor target: ${editorId}`);
-    }
-    return target;
-}
-export async function listAvailableEditorTargets(dependencies = {}) {
-    const platform = dependencies.platform ?? process.platform;
-    const findExecutableFn = dependencies.findExecutable ?? findExecutable;
-    const supportedTargets = EDITOR_TARGETS.filter((target) => isTargetSupportedOnPlatform(target, platform));
-    const executables = await Promise.all(supportedTargets.map((target) => findExecutableFn(target.command)));
-    const results = [];
-    for (let i = 0; i < supportedTargets.length; i += 1) {
-        if (!executables[i])
-            continue;
-        const target = supportedTargets[i];
-        results.push({
-            id: target.id,
-            label: target.label,
-        });
-    }
-    return results;
-}
-async function resolveEditorLaunch(input) {
-    const target = resolveEditorTargetDefinition(input.editorId);
-    if (!isTargetSupportedOnPlatform(target, input.platform)) {
-        throw new Error(`Editor target unavailable: ${target.label}`);
-    }
-    const executable = await input.findExecutableFn(target.command);
-    if (!executable) {
-        throw new Error(`Editor target unavailable: ${target.label}`);
-    }
-    return {
-        command: executable,
-        args: [input.path],
-    };
-}
-export async function openInEditorTarget(input, dependencies = {}) {
-    const platform = dependencies.platform ?? process.platform;
-    const pathToOpen = input.path.trim();
-    const existsSyncFn = dependencies.existsSync ?? existsSync;
-    const findExecutableFn = dependencies.findExecutable ?? findExecutable;
-    const spawnFn = dependencies.spawn ?? spawnProcess;
-    if (!pathToOpen || !isAbsolutePath(pathToOpen)) {
-        throw new Error("Editor target path must be an absolute local path");
-    }
-    if (!existsSyncFn(pathToOpen)) {
-        throw new Error(`Path does not exist: ${pathToOpen}`);
-    }
-    const launch = await resolveEditorLaunch({
-        editorId: input.editorId,
-        path: pathToOpen,
-        platform,
-        findExecutableFn,
-    });
-    await new Promise((resolve, reject) => {
-        let child;
-        try {
-            child = spawnFn(launch.command, launch.args, {
-                detached: true,
-                env: createExternalProcessEnv(process.env),
-                shell: platform === "win32",
-                stdio: "ignore",
-            });
-        }
-        catch (error) {
-            reject(error);
-            return;
-        }
-        child.once("error", reject);
-        child.once("spawn", () => {
-            child.unref();
-            resolve();
-        });
-    });
-}
-//# sourceMappingURL=editor-targets.js.map

package/dist/server/utils/script-hostname.d.ts

@@ -1,8 +0,0 @@
-interface BuildScriptHostnameOptions {
-    projectSlug: string;
-    branchName: string | null;
-    scriptName: string;
-}
-export declare function buildScriptHostname({ projectSlug, branchName, scriptName, }: BuildScriptHostnameOptions): string;
-export {};
-//# sourceMappingURL=script-hostname.d.ts.map

package/dist/server/utils/script-hostname.js

@@ -1,14 +0,0 @@
-import { slugify } from "./worktree.js";
-function toHostnameLabel(value) {
-    return slugify(value) || "untitled";
-}
-export function buildScriptHostname({ projectSlug, branchName, scriptName, }) {
-    const serviceHostnameLabel = toHostnameLabel(scriptName);
-    const projectHostnameLabel = toHostnameLabel(projectSlug);
-    const isDefaultBranch = branchName === null || branchName === "main" || branchName === "master";
-    if (isDefaultBranch) {
-        return `${serviceHostnameLabel}.${projectHostnameLabel}.localhost`;
-    }
-    return `${serviceHostnameLabel}.${toHostnameLabel(branchName)}.${projectHostnameLabel}.localhost`;
-}
-//# sourceMappingURL=script-hostname.js.map