@getpaseo/server 0.1.89 → 0.1.90

package/dist/server/server/workspace-directory.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { sep } from "node:path";
 import { deriveAgentStateBucket, getWorkspaceStateBucketPriority, } from "@getpaseo/protocol/agent-state-bucket";
-import { isDelegatedAgent } from "@getpaseo/protocol/agent-labels";
+import { getParentAgentIdFromLabels, isDelegatedAgent } from "@getpaseo/protocol/agent-labels";
 import { SortablePager } from "./pagination/sortable-pager.js";
 import { normalizeWorkspaceId } from "./workspace-registry-model.js";
 const FETCH_WORKSPACES_SORT_KEYS = [
@@ -35,6 +35,12 @@ export class WorkspaceDirectory {
     constructor(deps) {
         this.deps = deps;
         this.archivingByWorkspaceId = new Map();
+        /**
+         * Per-workspace last-seen winning bucket + entered-at. Persists across
+         * `buildDescriptorMap` calls inside the daemon process; reset on cold start.
+         * Server-internal; never crosses the wire.
+         */
+        this.bucketHistoryByWorkspaceId = new Map();
         this.pager = new SortablePager({
             validKeys: FETCH_WORKSPACES_SORT_KEYS,
             defaultSort: [{ key: "activity_at", direction: "desc" }],
@@ -93,17 +99,31 @@ export class WorkspaceDirectory {
                 archivingAt: this.archivingByWorkspaceId.get(workspaceId) ?? null,
             });
         }
-        for (const agent of agents) {
-            if (agent.archivedAt) {
-                continue;
-            }
-            if (!this.deps.isProviderVisibleToClient(agent.provider)) {
-                continue;
-            }
+        const activeAgents = agents.filter((agent) => !agent.archivedAt && this.deps.isProviderVisibleToClient(agent.provider));
+        const activeAgentsById = new Map(activeAgents.map((agent) => [agent.id, agent]));
+        for (const agent of activeAgents) {
+            let workspaceAgent = agent;
+            let bucket;
             if (isDelegatedAgent(agent)) {
-                continue;
+                if (agent.status !== "running") {
+                    continue;
+                }
+                const parentAgent = resolveDelegationRootAgent(agent, activeAgentsById);
+                if (!parentAgent) {
+                    continue;
+                }
+                workspaceAgent = parentAgent;
+                bucket = "running";
             }
-            const workspaceId = workspaceIdsByDirectory.get(normalizeWorkspaceId(agent.cwd));
+            else {
+                bucket = deriveAgentStateBucket({
+                    status: agent.status,
+                    pendingPermissionCount: agent.pendingPermissions?.length ?? 0,
+                    requiresAttention: agent.requiresAttention,
+                    attentionReason: agent.attentionReason ?? null,
+                });
+            }
+            const workspaceId = workspaceIdsByDirectory.get(normalizeWorkspaceId(workspaceAgent.cwd));
             if (workspaceId === undefined) {
                 continue;
             }
@@ -111,17 +131,104 @@ export class WorkspaceDirectory {
             if (!existing) {
                 continue;
             }
-            const bucket = deriveAgentStateBucket({
+            if (getWorkspaceStateBucketPriority(bucket) < getWorkspaceStateBucketPriority(existing.status)) {
+                existing.status = bucket;
+            }
+        }
+        // Resolve the workspace-level `statusEnteredAt` (see aggregate semantics
+        // on `resolveStatusEnteredAt`).
+        const nowIso = new Date().toISOString();
+        for (const [workspaceId, descriptor] of descriptorsByWorkspaceId) {
+            const contributingAgents = agents.filter((agent) => !agent.archivedAt &&
+                this.deps.isProviderVisibleToClient(agent.provider) &&
+                workspaceIdsByDirectory.get(normalizeWorkspaceId(agent.cwd)) === workspaceId);
+            const result = this.resolveStatusEnteredAt({
+                workspaceId,
+                winningBucket: descriptor.status,
+                contributingAgents,
+                previous: this.bucketHistoryByWorkspaceId.get(workspaceId) ?? null,
+                nowIso,
+            });
+            descriptor.statusEnteredAt = result.statusEnteredAt;
+            if (result.recordUpdate) {
+                this.bucketHistoryByWorkspaceId.set(workspaceId, result.recordUpdate);
+            }
+            else if (result.recordDelete) {
+                this.bucketHistoryByWorkspaceId.delete(workspaceId);
+            }
+        }
+        return descriptorsByWorkspaceId;
+    }
+    // Aggregate the workspace-level `statusEnteredAt` from its contributing
+    // agents. Aggregate semantics:
+    //   - winning bucket = highest-priority across contributing agents;
+    //   - entry time = best-effort timestamp from agents in the winning bucket;
+    //   - priority unmasking: when the winning bucket transitions (e.g. a
+    //     higher-priority bucket cleared), the new entry time is "now";
+    //   - same-bucket emits reuse the previous entered-at;
+    //   - empty workspaces that never had contributing agents get
+    //     `statusEnteredAt: null`.
+    //   - when archived agents leave a previously active workspace empty, keep
+    //     the previous done timestamp or stamp the transition to done now.
+    resolveStatusEnteredAt(params) {
+        const { winningBucket, contributingAgents, previous, nowIso } = params;
+        if (contributingAgents.length === 0) {
+            if (!previous) {
+                return { statusEnteredAt: null };
+            }
+            const enteredAt = previous.bucket === "done" ? previous.enteredAt : nowIso;
+            return {
+                statusEnteredAt: enteredAt,
+                recordUpdate: { bucket: "done", enteredAt },
+            };
+        }
+        if (!previous) {
+            const newestInWinningBucket = this.findNewestAgentTimestampInBucket(contributingAgents, winningBucket);
+            const enteredAt = newestInWinningBucket ?? nowIso;
+            return {
+                statusEnteredAt: enteredAt,
+                recordUpdate: { bucket: winningBucket, enteredAt },
+            };
+        }
+        if (previous.bucket !== winningBucket) {
+            return {
+                statusEnteredAt: nowIso,
+                recordUpdate: { bucket: winningBucket, enteredAt: nowIso },
+            };
+        }
+        return {
+            statusEnteredAt: previous.enteredAt,
+            recordUpdate: previous,
+        };
+    }
+    // Best-effort newest timestamp across contributing agents whose derived
+    // bucket matches `winningBucket`. Uses available agent fields:
+    //   - `attentionTimestamp` when attention is set (covers attention/failed)
+    //   - `updatedAt` as a general fallback for any bucket
+    // Returns `null` if no matching agent has a parseable timestamp.
+    findNewestAgentTimestampInBucket(contributingAgents, winningBucket) {
+        const candidates = contributingAgents
+            .filter((agent) => {
+            const derived = deriveAgentStateBucket({
                 status: agent.status,
                 pendingPermissionCount: agent.pendingPermissions?.length ?? 0,
                 requiresAttention: agent.requiresAttention,
                 attentionReason: agent.attentionReason ?? null,
             });
-            if (getWorkspaceStateBucketPriority(bucket) < getWorkspaceStateBucketPriority(existing.status)) {
-                existing.status = bucket;
+            return derived === winningBucket;
+        })
+            .map((agent) => {
+            // Prefer attentionTimestamp when the agent has attention set — this is
+            // the most accurate "entered current status" signal.
+            if (agent.attentionTimestamp) {
+                return agent.attentionTimestamp;
             }
-        }
-        return descriptorsByWorkspaceId;
+            // Fall back to updatedAt as a general proxy for recent activity.
+            return agent.updatedAt;
+        })
+            .filter((value) => typeof value === "string" && value.length > 0)
+            .sort();
+        return candidates.at(-1) ?? null;
     }
     resolveRegisteredWorkspaceIdForCwd(cwd, workspaces) {
         const normalizedCwd = normalizeWorkspaceId(cwd);
@@ -215,4 +322,23 @@ export class WorkspaceDirectory {
         };
     }
 }
+function resolveDelegationRootAgent(agent, activeAgentsById) {
+    const seen = new Set([agent.id]);
+    let current = agent;
+    while (true) {
+        const parentAgentId = getParentAgentIdFromLabels(current.labels);
+        if (!parentAgentId) {
+            return current;
+        }
+        if (seen.has(parentAgentId)) {
+            return null;
+        }
+        const parent = activeAgentsById.get(parentAgentId);
+        if (!parent) {
+            return null;
+        }
+        seen.add(parentAgentId);
+        current = parent;
+    }
+}
 //# sourceMappingURL=workspace-directory.js.map

package/dist/server/server/workspace-registry.js

@@ -1,7 +1,6 @@
-import { randomUUID } from "node:crypto";
 import { promises as fs } from "node:fs";
-import path from "node:path";
 import { z } from "zod";
+import { writeJsonFileAtomic } from "./atomic-file.js";
 const PersistedProjectRecordSchema = z.object({
     projectId: z.string(),
     rootPath: z.string(),
@@ -110,10 +109,7 @@ class FileBackedRegistry {
     }
     async persist() {
         const records = Array.from(this.cache.values());
-        await fs.mkdir(path.dirname(this.filePath), { recursive: true });
-        const tempPath = `${this.filePath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
-        await fs.writeFile(tempPath, JSON.stringify(records, null, 2), "utf8");
-        await fs.rename(tempPath, this.filePath);
+        await writeJsonFileAtomic(this.filePath, records);
     }
     async enqueuePersist() {
         const nextPersist = this.persistQueue.then(() => this.persist());

package/dist/server/utils/checkout-git.d.ts

@@ -150,7 +150,6 @@ export type CheckoutSnapshotFacts = {
     comparisonBaseRef: string | null;
     branchRemoteName: string | null;
     branchMergeRef: string | null;
-    trackedOriginBranch: string | null;
     pullRequestLookupTarget: PullRequestStatusLookupTarget | null;
 };
 export declare function getCurrentBranch(cwd: string): Promise<string | null>;

package/dist/server/utils/checkout-git.js

@@ -975,52 +975,46 @@ async function getAheadBehind(cwd, baseRef, currentBranch, context) {
     }
     return { ahead, behind };
 }
-async function getAheadOfOrigin(cwd, currentBranch, baseRef, context) {
+async function getAheadOfOrigin(cwd, currentBranch, context) {
     if (!currentBranch) {
         return null;
     }
-    const trackedOriginBranch = await getTrackedOriginBranch(cwd, currentBranch, context);
-    const originBranch = trackedOriginBranch ?? currentBranch;
+    const upstreamRef = await getConfiguredUpstreamRef(cwd, currentBranch, context);
+    if (!upstreamRef) {
+        return null;
+    }
     try {
-        const { stdout } = await runGitCommand(["rev-list", "--count", `origin/${originBranch}..${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
+        const { stdout } = await runGitCommand(["rev-list", "--count", `${upstreamRef}..${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
         const count = Number.parseInt(stdout.trim(), 10);
         return Number.isNaN(count) ? null : count;
     }
     catch {
-        if (trackedOriginBranch) {
-            return null;
-        }
-        if (!baseRef || normalizeLocalBranchRefName(baseRef) === currentBranch) {
-            return null;
-        }
-        try {
-            const comparisonBaseRef = await resolveBestComparisonBaseRef(cwd, baseRef, context);
-            const { stdout } = await runGitCommand(["rev-list", "--count", `${comparisonBaseRef}..${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
-            const count = Number.parseInt(stdout.trim(), 10);
-            return Number.isNaN(count) ? null : count;
-        }
-        catch {
-            return null;
-        }
+        return null;
     }
 }
-async function getTrackedOriginBranch(cwd, currentBranch, context) {
-    if (context?.facts?.isGit && context.facts.currentBranch === currentBranch) {
-        return context.facts.trackedOriginBranch;
-    }
-    const remoteName = await getGitConfigValue(cwd, `branch.${currentBranch}.remote`, context);
-    if (remoteName !== "origin") {
+async function getConfiguredUpstreamRef(cwd, currentBranch, context) {
+    const remoteName = context?.facts?.isGit && context.facts.currentBranch === currentBranch
+        ? context.facts.branchRemoteName
+        : await getGitConfigValue(cwd, `branch.${currentBranch}.remote`, context);
+    if (!remoteName) {
         return null;
     }
-    const mergeRef = await getGitConfigValue(cwd, `branch.${currentBranch}.merge`, context);
-    return parseBranchMergeHeadRef(mergeRef);
+    const mergeRef = context?.facts?.isGit && context.facts.currentBranch === currentBranch
+        ? context.facts.branchMergeRef
+        : await getGitConfigValue(cwd, `branch.${currentBranch}.merge`, context);
+    const upstreamBranch = parseBranchMergeHeadRef(mergeRef);
+    return upstreamBranch ? `${remoteName}/${upstreamBranch}` : null;
 }
 async function getBehindOfOrigin(cwd, currentBranch, context) {
     if (!currentBranch) {
         return null;
     }
+    const upstreamRef = await getConfiguredUpstreamRef(cwd, currentBranch, context);
+    if (!upstreamRef) {
+        return null;
+    }
     try {
-        const { stdout } = await runGitCommand(["rev-list", "--count", `${currentBranch}..origin/${currentBranch}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
+        const { stdout } = await runGitCommand(["rev-list", "--count", `${currentBranch}..${upstreamRef}`], { cwd, envOverlay: READ_ONLY_GIT_ENV, logger: context?.logger });
         const count = Number.parseInt(stdout.trim(), 10);
         return Number.isNaN(count) ? null : count;
     }
@@ -1105,7 +1099,6 @@ export async function getCheckoutSnapshotFacts(cwd, context) {
             }
         }
     }
-    const trackedOriginBranch = branchRemoteName === "origin" ? parseBranchMergeHeadRef(branchMergeRef) : null;
     const pullRequestLookupTarget = inspected.currentBranch
         ? buildPullRequestLookupTargetFromBranchConfig({
             currentBranch: inspected.currentBranch,
@@ -1128,7 +1121,6 @@ export async function getCheckoutSnapshotFacts(cwd, context) {
         comparisonBaseRef,
         branchRemoteName,
         branchMergeRef,
-        trackedOriginBranch,
         pullRequestLookupTarget,
     };
 }
@@ -1238,7 +1230,7 @@ export async function getCheckoutStatus(cwd, context) {
             ? getAheadBehind(cwd, baseRef, currentBranch, factsContext)
             : Promise.resolve(null),
         hasRemote && currentBranch
-            ? getAheadOfOrigin(cwd, currentBranch, baseRef, factsContext)
+            ? getAheadOfOrigin(cwd, currentBranch, factsContext)
             : Promise.resolve(null),
         hasRemote && currentBranch
             ? getBehindOfOrigin(cwd, currentBranch, factsContext)

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
@@ -296,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) {
@@ -347,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.89",
+  "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.89",
-    "@getpaseo/highlight": "0.1.89",
-    "@getpaseo/protocol": "0.1.89",
-    "@getpaseo/relay": "0.1.89",
+    "@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