@neuralnomads/codenomad-dev 0.18.0-dev-20260715-07e8ce68 → 0.18.0-dev-20260716-40cee071

package/dist/usage/shared.js

@@ -0,0 +1,130 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+const REQUEST_TIMEOUT_MS = 15000;
+function authFileCandidates() {
+    const home = os.homedir();
+    const candidates = [
+        process.env.OPENCODE_AUTH_FILE,
+        process.env.OPENCODE_DATA_DIR ? path.join(process.env.OPENCODE_DATA_DIR, "auth.json") : undefined,
+        process.env.XDG_DATA_HOME ? path.join(process.env.XDG_DATA_HOME, "opencode", "auth.json") : undefined,
+        path.join(home, ".local", "share", "opencode", "auth.json"),
+        process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, "opencode", "Data", "auth.json") : undefined,
+        process.env.APPDATA ? path.join(process.env.APPDATA, "opencode", "auth.json") : undefined,
+        path.join(home, "Library", "Application Support", "opencode", "auth.json"),
+    ];
+    return Array.from(new Set(candidates.filter((candidate) => Boolean(candidate))));
+}
+export function readOpenCodeAuth() {
+    for (const candidate of authFileCandidates()) {
+        try {
+            const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+                return parsed;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                continue;
+        }
+    }
+    return {};
+}
+export function getAuthEntry(aliases) {
+    const auth = readOpenCodeAuth();
+    for (const alias of aliases) {
+        const value = auth[alias];
+        if (typeof value === "string" && value.trim())
+            return { token: value.trim() };
+        if (value && typeof value === "object" && !Array.isArray(value))
+            return value;
+    }
+    return null;
+}
+export function getString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+export function getCredential(aliases, fields) {
+    const entry = getAuthEntry(aliases);
+    if (!entry)
+        return null;
+    for (const field of fields) {
+        const value = getString(entry[field]);
+        if (value)
+            return value;
+    }
+    return null;
+}
+export function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+export function toNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+export function toTimestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value < 1000000000000 ? value * 1000 : value;
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Date.parse(value);
+        return Number.isNaN(parsed) ? null : parsed;
+    }
+    return null;
+}
+export function toUsageWindow(input) {
+    const usedPercent = input.usedPercent === null ? null : Math.max(0, Math.min(100, input.usedPercent));
+    return {
+        usedPercent,
+        remainingPercent: usedPercent === null ? null : 100 - usedPercent,
+        windowSeconds: input.windowSeconds ?? null,
+        resetAt: input.resetAt ?? null,
+        ...(input.valueLabel ? { valueLabel: input.valueLabel } : {}),
+    };
+}
+export function resolveWindowLabel(windowSeconds) {
+    if (!windowSeconds)
+        return "usage";
+    if (windowSeconds % 86400 === 0) {
+        const days = windowSeconds / 86400;
+        return days === 7 ? "weekly" : `${days}d`;
+    }
+    if (windowSeconds % 3600 === 0)
+        return `${windowSeconds / 3600}h`;
+    return `${windowSeconds}s`;
+}
+export function result(providerId, providerName, input) {
+    return {
+        providerId,
+        providerName,
+        ok: input.ok,
+        configured: input.configured,
+        usage: input.usage ?? null,
+        fetchedAt: Date.now(),
+        ...(input.error ? { error: input.error } : {}),
+    };
+}
+export function notConfigured(providerId, providerName) {
+    return result(providerId, providerName, { ok: false, configured: false, error: "Not configured" });
+}
+export async function fetchJson(url, init = {}) {
+    const response = await fetch(url, { ...init, signal: init.signal ?? AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+    if (!response.ok)
+        throw new Error(`Provider returned HTTP ${response.status}`);
+    return response.json();
+}
+export async function safeFetch(providerId, providerName, operation) {
+    try {
+        return result(providerId, providerName, { ok: true, configured: true, usage: await operation() });
+    }
+    catch (error) {
+        return result(providerId, providerName, {
+            ok: false,
+            configured: true,
+            error: error instanceof Error ? error.message : "Request failed",
+        });
+    }
+}

package/dist/usage/shared.test.js

@@ -0,0 +1,33 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { getCredential, readOpenCodeAuth, toTimestamp, toUsageWindow } from "./shared";
+test("reads the explicit OpenCode auth file without exposing credentials through the API", () => {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "codenomad-usage-"));
+    const authFile = path.join(directory, "auth.json");
+    const previous = process.env.OPENCODE_AUTH_FILE;
+    fs.writeFileSync(authFile, JSON.stringify({ anthropic: { type: "oauth", access: "secret-token" } }));
+    process.env.OPENCODE_AUTH_FILE = authFile;
+    try {
+        assert.equal(readOpenCodeAuth().anthropic.access, "secret-token");
+        assert.equal(getCredential(["anthropic"], ["access"]), "secret-token");
+    }
+    finally {
+        if (previous === undefined)
+            delete process.env.OPENCODE_AUTH_FILE;
+        else
+            process.env.OPENCODE_AUTH_FILE = previous;
+        fs.rmSync(directory, { recursive: true, force: true });
+    }
+});
+test("normalizes percentages and timestamps", () => {
+    assert.deepEqual(toUsageWindow({ usedPercent: 120, resetAt: null }), {
+        usedPercent: 100,
+        remainingPercent: 0,
+        windowSeconds: null,
+        resetAt: null,
+    });
+    assert.equal(toTimestamp(1700000000), 1700000000000);
+});

package/dist/usage/types.js

@@ -0,0 +1 @@
+export {};

package/dist/workspaces/__tests__/spawn.test.js

@@ -1,6 +1,9 @@
 import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
 import { describe, it } from "node:test";
-import { buildWindowsSpawnSpec, buildWslSignalSpec, parseWslUncPath, resolveWslWorkingDirectory } from "../spawn";
+import { buildWindowsSpawnSpec, parseWslUncPath, resolveWslWorkingDirectory } from "../spawn";
 describe("parseWslUncPath", () => {
     it("parses WSL UNC paths into distro and linux path", () => {
         assert.deepEqual(parseWslUncPath(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`), {
@@ -30,6 +33,62 @@ describe("resolveWslWorkingDirectory", () => {
     });
 });
 describe("buildWindowsSpawnSpec", () => {
+    it("classifies native executables separately from script and shell wrappers", () => {
+        assert.equal(buildWindowsSpawnSpec("opencode.exe", []).processKind, "windows-direct");
+        assert.equal(buildWindowsSpawnSpec("opencode.cmd", []).processKind, "windows-wrapper");
+        assert.equal(buildWindowsSpawnSpec("powershell.exe", []).processKind, "windows-wrapper");
+    });
+    it("conservatively classifies bare commands as wrappers", () => {
+        assert.equal(buildWindowsSpawnSpec("opencode", []).processKind, "windows-wrapper");
+    });
+    it("resolves a bare cmd shim from a quoted PATH entry and wraps its absolute path", () => {
+        const root = mkdtempSync(path.join(tmpdir(), "codenomad-spawn-"));
+        const cwd = path.join(root, "workspace");
+        const bin = path.join(root, "bin with spaces");
+        mkdirSync(cwd);
+        mkdirSync(bin);
+        const shim = path.join(bin, "opencode.cmd");
+        writeFileSync(shim, "@echo off\r\n");
+        try {
+            const spec = buildWindowsSpawnSpec("opencode", ["serve"], {
+                cwd,
+                env: { Path: `"${bin}"`, PathExt: ".CMD;.EXE", ComSpec: "test-cmd.exe" },
+            });
+            assert.equal(spec.command, "test-cmd.exe");
+            assert.equal(spec.processKind, "windows-wrapper");
+            assert.equal(spec.options.windowsVerbatimArguments, true);
+            assert.match(spec.args[3] ?? "", new RegExp(escapeRegex(path.win32.resolve(shim)), "i"));
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("honors PATHEXT precedence when both native and shim files exist", () => {
+        const root = mkdtempSync(path.join(tmpdir(), "codenomad-spawn-"));
+        writeFileSync(path.join(root, "opencode.cmd"), "@echo off\r\n");
+        writeFileSync(path.join(root, "opencode.exe"), "");
+        try {
+            const spec = buildWindowsSpawnSpec("opencode", [], {
+                cwd: root,
+                env: { PATH: "", PATHEXT: ".EXE;.CMD" },
+            });
+            assert.equal(spec.command.toLowerCase(), path.win32.resolve(root, "opencode.exe").toLowerCase());
+            assert.equal(spec.processKind, "windows-direct");
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+    it("leaves an unresolved bare command unchanged without injecting a shell", () => {
+        const spec = buildWindowsSpawnSpec("missing-opencode", ["serve"], {
+            cwd: String.raw `C:\missing-workspace`,
+            env: { PATH: "", PATHEXT: ".CMD;.EXE", ComSpec: "must-not-run.exe" },
+        });
+        assert.equal(spec.command, "missing-opencode");
+        assert.deepEqual(spec.args, ["serve"]);
+        assert.equal(spec.processKind, "windows-wrapper");
+        assert.equal(spec.options.windowsVerbatimArguments, undefined);
+    });
     it("wraps WSL binaries with wsl.exe and propagates required env vars", () => {
         const spec = buildWindowsSpawnSpec(String.raw `\\wsl.localhost\Ubuntu\home\dev\.opencode\bin\opencode`, ["serve", "--port", "0"], {
             cwd: String.raw `\\wsl.localhost\Ubuntu\home\dev\workspace`,
@@ -142,7 +201,7 @@ describe("buildWindowsSpawnSpec", () => {
             "--exec",
             "sh",
             "-lc",
-            `printf '%s%s\\n' '__CODENOMAD_WSL_PID__:' "$$" && cd "$1" && shift && exec "$@"`,
+            `codenomad_pgid=$(ps -o pgid= -p "$$" 2>/dev/null | tr -d '[:space:]'); codenomad_start=$(awk '{print $22}' "/proc/$$/stat" 2>/dev/null); codenomad_boot=$(cat /proc/sys/kernel/random/boot_id 2>/dev/null); test -n "$codenomad_pgid" && test -n "$codenomad_start" && test -n "$codenomad_boot" && printf '%s%s:%s:%s:%s\\n' '__CODENOMAD_WSL_PID__:' "$$" "$codenomad_pgid" "$codenomad_start" "$codenomad_boot" && cd "$1" && shift && exec "$@"`,
             "codenomad-wsl-launch",
             "/home/dev/workspace",
             "/home/dev/.opencode/bin/opencode",
@@ -150,9 +209,7 @@ describe("buildWindowsSpawnSpec", () => {
         ]);
         assert.equal(spec.wsl?.pidMarker, "__CODENOMAD_WSL_PID__:");
     });
-    it("builds the WSL kill command for tracked Linux PIDs", () => {
-        const spec = buildWslSignalSpec("Ubuntu", 4321, "SIGTERM");
-        assert.equal(spec.command, "wsl.exe");
-        assert.deepEqual(spec.args, ["--distribution", "Ubuntu", "--exec", "kill", "-TERM", "4321"]);
-    });
 });
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/workspaces/__tests__/workspace-identity.test.js

@@ -35,7 +35,7 @@ function createManager(rootDir) {
         rootDir,
         settings: { getOwner: () => ({ environmentVariables: {} }) },
         binaryResolver: {
-            resolveDefault: () => ({ path: process.execPath, label: "Node.js", version: process.version }),
+            resolve: () => ({ path: process.execPath, label: "Node.js", version: process.version }),
         },
         eventBus: new EventBus(logger),
         logger,
@@ -46,6 +46,7 @@ function createManager(rootDir) {
         pid: 123,
         port: 4321,
         exitPromise: new Promise(() => { }),
+        cancellationPromise: new Promise(() => { }),
         getLastOutput: () => "",
     });
     internal.waitForWorkspaceReadiness = async () => undefined;
@@ -84,40 +85,139 @@ describe("workspace identity", () => {
     it("shares an in-flight startup between canonical aliases", async () => {
         const { root, target, link } = await createLinkedWorkspace();
         const manager = createManager(root);
+        const launchGate = deferred();
         let launches = 0;
         manager.runtime.launch = async () => {
             launches += 1;
-            await new Promise((resolve) => setTimeout(resolve, 20));
+            await launchGate.promise;
             return {
                 pid: 123,
                 port: 4321,
                 exitPromise: new Promise(() => { }),
+                cancellationPromise: new Promise(() => { }),
                 getLastOutput: () => "",
             };
         };
-        const [first, second] = await Promise.all([manager.create(target), manager.create(link)]);
+        const firstPromise = manager.create(target, undefined, { requestId: "restore-request" });
+        const secondPromise = manager.create(link);
+        while (![...manager.pendingWorkspaceCreations.values()][0]?.followerCount) {
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        launchGate.resolve();
+        const [first, second] = await Promise.all([firstPromise, secondPromise]);
         assert.equal(launches, 1);
-        assert.equal(Number(first.created) + Number(second.created), 1);
+        assert.equal(first.created, false);
+        assert.equal(first.workspace.requestId, undefined);
         assert.equal(first.workspace.id, second.workspace.id);
         assert.equal(first.workspace.status, "ready");
         assert.equal(second.workspace.status, "ready");
     });
+    it("keeps both cleanup owners when two restore requests share a canonical launch", async () => {
+        const { root, target, link } = await createLinkedWorkspace();
+        const manager = createManager(root);
+        const [first, second] = await Promise.all([
+            manager.create(target, undefined, { requestId: "restore-first" }),
+            manager.create(link, undefined, { requestId: "restore-second" }),
+        ]);
+        assert.equal(Number(first.created) + Number(second.created), 1);
+        assert.equal(first.workspace.id, second.workspace.id);
+        assert.equal(first.workspace.requestId, "restore-first");
+        assert.equal(second.workspace.requestId, "restore-second");
+        assert.equal(manager.releaseCreationRequest(first.workspace.id, "restore-first"), true);
+        assert.equal(manager.releaseCreationRequest(first.workspace.id, "restore-second"), true);
+    });
+    it("detaches a cancelled restore follower without stopping the leader launch", async () => {
+        const { root, target, link } = await createLinkedWorkspace();
+        const manager = createManager(root);
+        const launchGate = deferred();
+        let launches = 0;
+        manager.runtime.launch = async () => {
+            launches += 1;
+            await launchGate.promise;
+            return {
+                pid: 123,
+                port: 4321,
+                exitPromise: new Promise(() => { }),
+                cancellationPromise: new Promise(() => { }),
+                getLastOutput: () => "",
+            };
+        };
+        const leader = manager.create(target, undefined, { requestId: "restore-leader" });
+        const follower = manager.create(link, undefined, { requestId: "restore-follower" });
+        while (![...manager.pendingWorkspaceCreations.values()][0]?.followerCount) {
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        await manager.cancelCreationRequest("restore-follower");
+        launchGate.resolve();
+        const leaderResult = await leader;
+        await assert.rejects(follower, /creation request restore-follower was cancelled/);
+        assert.equal(launches, 1);
+        assert.equal(leaderResult.workspace.requestId, "restore-leader");
+        assert.equal(manager.list().length, 1);
+    });
+    it("detaches a cancelled restore leader without stopping a follower launch", async () => {
+        const { root, target, link } = await createLinkedWorkspace();
+        const manager = createManager(root);
+        const launchGate = deferred();
+        manager.runtime.launch = async () => {
+            await launchGate.promise;
+            return {
+                pid: 123,
+                port: 4321,
+                exitPromise: new Promise(() => { }),
+                cancellationPromise: new Promise(() => { }),
+                getLastOutput: () => "",
+            };
+        };
+        const leader = manager.create(target, undefined, { requestId: "restore-leader" });
+        const follower = manager.create(link, undefined, { requestId: "restore-follower" });
+        while (![...manager.pendingWorkspaceCreations.values()][0]?.followerCount) {
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        await manager.cancelCreationRequest("restore-leader");
+        launchGate.resolve();
+        await assert.rejects(leader, /creation request restore-leader was cancelled/);
+        const followerResult = await follower;
+        assert.equal(followerResult.workspace.requestId, "restore-follower");
+        assert.equal(manager.list().length, 1);
+    });
+    it("retains a shared workspace after one restore owner releases and another cancels", async () => {
+        const { root, target, link } = await createLinkedWorkspace();
+        const manager = createManager(root);
+        const [first, second] = await Promise.all([
+            manager.create(target, undefined, { requestId: "restore-first" }),
+            manager.create(link, undefined, { requestId: "restore-second" }),
+        ]);
+        assert.equal(manager.releaseCreationRequest(first.workspace.id, "restore-first"), true);
+        await manager.cancelCreationRequest("restore-second");
+        assert.equal(manager.list().length, 1);
+        assert.equal(manager.get(second.workspace.id)?.requestId, undefined);
+        assert.equal(manager.releaseCreationRequest(second.workspace.id, "restore-second"), true);
+    });
     it("releases a failed identity reservation so creation can be retried", async () => {
         const { root, target, link } = await createLinkedWorkspace();
         const manager = createManager(root);
+        const launchGate = deferred();
         let launches = 0;
         manager.runtime.launch = async () => {
             launches += 1;
-            await new Promise((resolve) => setTimeout(resolve, 20));
+            await launchGate.promise;
             throw new Error("launch failed");
         };
-        const failed = await Promise.allSettled([manager.create(target), manager.create(link)]);
+        const firstFailure = manager.create(target);
+        const secondFailure = manager.create(link);
+        while (![...manager.pendingWorkspaceCreations.values()][0]?.followerCount) {
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        launchGate.resolve();
+        const failed = await Promise.allSettled([firstFailure, secondFailure]);
         assert.deepEqual(failed.map((result) => result.status), ["rejected", "rejected"]);
         assert.equal(launches, 1);
         manager.runtime.launch = async () => ({
             pid: 456,
             port: 5432,
             exitPromise: new Promise(() => { }),
+            cancellationPromise: new Promise(() => { }),
             getLastOutput: () => "",
         });
         const retry = await manager.create(target);
@@ -136,30 +236,50 @@ describe("workspace identity", () => {
         assert.notEqual(first.workspace.id, second.workspace.id);
         assert.equal(manager.list().length, 2);
     });
+    it("does not reuse restore-owned workspaces until hydration releases ownership", async () => {
+        const { root, target, link } = await createLinkedWorkspace();
+        const manager = createManager(root);
+        const restore = await manager.create(target, undefined, {
+            forceNew: true,
+            requestId: "restore-request",
+        });
+        const concurrent = await manager.create(link);
+        assert.equal(concurrent.created, true);
+        assert.notEqual(concurrent.workspace.id, restore.workspace.id);
+        assert.equal(manager.releaseCreationRequest(restore.workspace.id, "wrong-request"), false);
+        assert.equal(manager.releaseCreationRequest(restore.workspace.id, "restore-request"), true);
+        assert.equal(manager.releaseCreationRequest(restore.workspace.id, "restore-request"), true);
+        await manager.delete(concurrent.workspace.id);
+        const reused = await manager.create(link);
+        assert.equal(reused.created, false);
+        assert.equal(reused.workspace.id, restore.workspace.id);
+    });
     it("keeps the canonical reservation when a forced duplicate is deleted", async () => {
         const { root, target, link } = await createLinkedWorkspace();
         const manager = createManager(root);
         const normalLaunch = deferred();
         const forcedLaunch = deferred();
         let launches = 0;
-        manager.runtime.launch = () => {
+        const launchedWorkspaceIds = [];
+        manager.runtime.launch = (options) => {
             launches += 1;
+            launchedWorkspaceIds.push(options.workspaceId);
             return launches === 1 ? normalLaunch.promise : forcedLaunch.promise;
         };
         const first = manager.create(target);
-        while (manager.list().length < 1) {
+        while (launchedWorkspaceIds.length < 1) {
             await new Promise((resolve) => setImmediate(resolve));
         }
         const forced = manager.create(link, undefined, { forceNew: true });
-        const forcedRejected = assert.rejects(forced, /Workspace creation cancelled/);
-        while (manager.list().length < 2) {
+        const forcedRejected = assert.rejects(forced, /launch was cancelled/);
+        while (launchedWorkspaceIds.length < 2) {
             await new Promise((resolve) => setImmediate(resolve));
         }
-        const forcedWorkspace = manager.list().find((workspace) => workspace.id !== manager.list()[0].id);
-        await manager.delete(forcedWorkspace.id);
+        const forcedDeletion = manager.delete(launchedWorkspaceIds[1]);
         const reused = manager.create(link);
-        normalLaunch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), getLastOutput: () => "" });
-        forcedLaunch.resolve({ pid: 456, port: 5432, exitPromise: new Promise(() => { }), getLastOutput: () => "" });
+        normalLaunch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), cancellationPromise: new Promise(() => { }), getLastOutput: () => "" });
+        forcedLaunch.resolve({ pid: 456, port: 5432, exitPromise: new Promise(() => { }), cancellationPromise: new Promise(() => { }), getLastOutput: () => "" });
+        await forcedDeletion;
         const [firstResult, reusedResult] = await Promise.all([first, reused]);
         await forcedRejected;
         assert.equal(launches, 2);
@@ -170,33 +290,65 @@ describe("workspace identity", () => {
         const { root, target } = await createLinkedWorkspace();
         const manager = createManager(root);
         const launch = deferred();
-        manager.runtime.launch = () => launch.promise;
+        let workspaceId = "";
+        manager.runtime.launch = (options) => {
+            workspaceId = options.workspaceId;
+            return launch.promise;
+        };
         const events = [];
         manager.options.eventBus.onEvent((event) => events.push(event));
         const creation = manager.create(target);
-        const creationRejected = assert.rejects(creation, /Workspace creation cancelled/);
-        while (manager.list().length === 0) {
+        const creationRejected = assert.rejects(creation, /launch was cancelled/);
+        while (!workspaceId) {
             await new Promise((resolve) => setImmediate(resolve));
         }
-        const workspaceId = manager.list()[0].id;
-        await manager.delete(workspaceId);
-        launch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), getLastOutput: () => "" });
-        await creationRejected;
+        const deletion = manager.delete(workspaceId);
+        launch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), cancellationPromise: new Promise(() => { }), getLastOutput: () => "" });
+        await Promise.all([creationRejected, deletion]);
         assert.equal(manager.get(workspaceId), undefined);
         assert.equal(events.filter((event) => event.type === "workspace.stopped" && event.workspaceId === workspaceId).length, 1);
     });
+    it("cancels an in-flight restore startup by request id", async () => {
+        const { root, target } = await createLinkedWorkspace();
+        const manager = createManager(root);
+        const launch = deferred();
+        let workspaceId = "";
+        manager.runtime.launch = (options) => {
+            workspaceId = options.workspaceId;
+            return launch.promise;
+        };
+        const creation = manager.create(target, undefined, { requestId: "cancel-restore" });
+        const creationRejected = assert.rejects(creation, /launch was cancelled/);
+        while (!workspaceId)
+            await new Promise((resolve) => setImmediate(resolve));
+        const cancellation = manager.cancelCreationRequest("cancel-restore");
+        launch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), cancellationPromise: new Promise(() => { }), getLastOutput: () => "" });
+        await Promise.all([creationRejected, cancellation]);
+        assert.equal(manager.get(workspaceId), undefined);
+    });
+    it("remembers cancellation that arrives before restore reservation", async () => {
+        const { root, target } = await createLinkedWorkspace();
+        const manager = createManager(root);
+        await manager.cancelCreationRequest("early-cancel");
+        await assert.rejects(manager.create(target, undefined, { requestId: "early-cancel" }), /creation request early-cancel was cancelled/);
+        assert.equal(manager.list().length, 0);
+    });
     it("waits for and cancels forced creations during shutdown", async () => {
         const { root, target } = await createLinkedWorkspace();
         const manager = createManager(root);
         const launch = deferred();
-        manager.runtime.launch = () => launch.promise;
+        let workspaceId = "";
+        manager.runtime.launch = (options) => {
+            workspaceId = options.workspaceId;
+            return launch.promise;
+        };
         const creation = manager.create(target, undefined, { forceNew: true });
-        const creationRejected = assert.rejects(creation, /Workspace creation cancelled/);
-        while (manager.list().length === 0) {
+        const creationRejected = assert.rejects(creation, /launch was cancelled/);
+        while (!workspaceId) {
             await new Promise((resolve) => setImmediate(resolve));
         }
         const shutdown = manager.shutdown();
-        launch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), getLastOutput: () => "" });
+        launch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), cancellationPromise: new Promise(() => { }), getLastOutput: () => "" });
         await Promise.all([creationRejected, shutdown]);
         assert.equal(manager.list().length, 0);
     });