mirror of
https://github.com/getpaseo/paseo.git
synced 2026-11-20 15:25:13 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9d9e75c7bd | ||
|
|
6dde6ae2dd | ||
|
|
ce3b16df35 | ||
|
|
b5f4bf6e39 | ||
|
|
59c2e1ff2c | ||
|
|
b2679012ff | ||
|
|
1a54471e29 | ||
|
|
fdfb36428d | ||
|
|
0919277fd7 | ||
|
|
e3b032844b | ||
|
|
d6c66922c7 | ||
|
|
8fc0e2349f | ||
|
|
9aec7dc204 | ||
|
|
ba325922d2 | ||
|
|
cbaa8c7c90 | ||
|
|
3e0568aa93 | ||
|
|
c1d10b4e75 | ||
|
|
524116e111 | ||
|
|
1230337165 |
@@ -471,6 +471,18 @@ Workspace records decide ownership, including explicit non-ownership after recov
|
||||
ownership checks prefer the marker-verified worktree root over the legacy
|
||||
path shape: a plugin can place a worktree several directories below the default worktrees root.
|
||||
|
||||
A plugin can also take over worktree creation, removal, and restoration with
|
||||
`server.registerWorktreeManager({ create, remove?, restore? })`. It runs after
|
||||
`worktree.create.before` and before `worktree.create.after`, with a 120-second timeout matching Git
|
||||
worktree commands. Paseo snapshots existing worktree paths before calling `create` so a manager
|
||||
cannot adopt a pre-existing directory as Paseo-owned, verifies Git worktree postconditions, records
|
||||
`worktreeManagerPluginId` in `paseo/worktree.json` and on the workspace record,
|
||||
and skips first-agent branch auto-rename. Removal saves `refs/paseo/kept-commits/<sha>` before
|
||||
calling the owning plugin's `remove`, and `create`, `remove`, and `restore` carry `untrusted` for fork
|
||||
change requests; `remove` and `restore` fall back to built-in Git when the plugin declines or is disabled. See the
|
||||
[worktree managers reference](../public-docs/plugins/reference.md#worktree-managers) and
|
||||
`plugin-examples/worktrunk`.
|
||||
|
||||
Emit from the operation owner, not a client subscription. Provider history replay must not trigger
|
||||
live hooks. Notifications must not be awaited inside agent mutations: a handler can send a prompt
|
||||
or answer a permission through its own daemon session. Awaiting it there deadlocks that command.
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { runCreateCommandWithDeps } from "./create.js";
|
||||
import { buildCreateWorktreeRequest, type WorktreeCreateOptions } from "./create-input.js";
|
||||
|
||||
const REPO = "/tmp/repo";
|
||||
@@ -77,3 +78,52 @@ describe("buildCreateWorktreeRequest", () => {
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("uses the explicit worktree creation RPC and returns the created worktree details", async () => {
|
||||
const result = await runCreateCommandWithDeps(
|
||||
{
|
||||
daemonTarget: { kind: "endpoint", host: "example.test:12345" },
|
||||
mode: "branch-off",
|
||||
newBranch: "topic",
|
||||
base: "main",
|
||||
cwd: REPO,
|
||||
},
|
||||
{
|
||||
connectToDaemon: async () => ({
|
||||
createPaseoWorktree: async (input) => {
|
||||
expect(input).toEqual({
|
||||
cwd: REPO,
|
||||
worktreeSlug: "topic",
|
||||
action: "branch-off",
|
||||
refName: "main",
|
||||
});
|
||||
return {
|
||||
workspace: {
|
||||
id: "wks_topic",
|
||||
projectId: "project",
|
||||
projectDisplayName: "Repo",
|
||||
projectRootPath: REPO,
|
||||
workspaceDirectory: `${REPO}/topic`,
|
||||
projectKind: "git",
|
||||
workspaceKind: "worktree",
|
||||
name: "topic",
|
||||
status: "idle",
|
||||
statusEnteredAt: null,
|
||||
activityAt: null,
|
||||
archivingAt: null,
|
||||
scripts: [],
|
||||
},
|
||||
error: null,
|
||||
requestId: "worktree-create",
|
||||
};
|
||||
},
|
||||
close: async () => {},
|
||||
}),
|
||||
},
|
||||
);
|
||||
expect(result.data).toEqual({
|
||||
name: "topic",
|
||||
branchName: "topic",
|
||||
worktreePath: `${REPO}/topic`,
|
||||
});
|
||||
});
|
||||
|
||||
@@ -26,11 +26,22 @@ function cmdError(code: string, message: string, details?: string): CommandError
|
||||
export async function runCreateCommand(
|
||||
options: WorktreeCreateOptions,
|
||||
_command: Command,
|
||||
): Promise<SingleResult<WorktreeCreateResult>> {
|
||||
return runCreateCommandWithDeps(options, { connectToDaemon });
|
||||
}
|
||||
|
||||
export async function runCreateCommandWithDeps(
|
||||
options: WorktreeCreateOptions,
|
||||
deps: {
|
||||
connectToDaemon(
|
||||
options: Parameters<typeof connectToDaemon>[0],
|
||||
): Promise<Pick<Awaited<ReturnType<typeof connectToDaemon>>, "createPaseoWorktree" | "close">>;
|
||||
},
|
||||
): Promise<SingleResult<WorktreeCreateResult>> {
|
||||
const cwd = options.cwd ?? process.cwd();
|
||||
const request = buildCreateWorktreeRequest(options, cwd);
|
||||
|
||||
const client = await connectToDaemon({ target: options.daemonTarget });
|
||||
const client = await deps.connectToDaemon({ target: options.daemonTarget });
|
||||
|
||||
try {
|
||||
const response = await client.createPaseoWorktree(request);
|
||||
|
||||
@@ -1623,6 +1623,106 @@ test("defaults session RPC waiters to sixty seconds", async () => {
|
||||
await expect(responsePromise).rejects.toThrow("No response to fetch_agent_request after 60000ms");
|
||||
});
|
||||
|
||||
test.each([
|
||||
[
|
||||
"archive_workspace_request",
|
||||
(client: DaemonClient) => client.archiveWorkspace("workspace-1"),
|
||||
(requestId: string) => ({
|
||||
type: "archive_workspace_response" as const,
|
||||
payload: {
|
||||
requestId,
|
||||
workspaceId: "workspace-1",
|
||||
archivedAt: "2026-01-01T00:00:00.000Z",
|
||||
error: null,
|
||||
},
|
||||
}),
|
||||
],
|
||||
[
|
||||
"paseo_worktree_archive_request",
|
||||
(client: DaemonClient) => client.archivePaseoWorktree({ worktreePath: "/repo/worktree" }),
|
||||
(requestId: string) => ({
|
||||
type: "paseo_worktree_archive_response" as const,
|
||||
payload: { requestId, success: true, removedAgents: [], error: null },
|
||||
}),
|
||||
],
|
||||
[
|
||||
"workspace.recovery.restore.request",
|
||||
(client: DaemonClient) => client.restoreWorkspace("workspace-1"),
|
||||
(requestId: string) => ({
|
||||
type: "workspace.recovery.restore.response" as const,
|
||||
payload: { requestId, workspaceId: "workspace-1", accepted: true, error: null },
|
||||
}),
|
||||
],
|
||||
[
|
||||
"workspace.archive.undo.request",
|
||||
(client: DaemonClient) => client.undoWorkspaceArchive("workspace-1"),
|
||||
(requestId: string) => ({
|
||||
type: "workspace.archive.undo.response" as const,
|
||||
payload: { requestId, workspaceId: "workspace-1", accepted: true, error: null },
|
||||
}),
|
||||
],
|
||||
[
|
||||
"open_project_request",
|
||||
(client: DaemonClient) => client.openProject("/repo/worktree"),
|
||||
(requestId: string) => ({
|
||||
type: "open_project_response" as const,
|
||||
payload: { requestId, workspace: null, error: null },
|
||||
}),
|
||||
],
|
||||
[
|
||||
"create_paseo_worktree_request",
|
||||
(client: DaemonClient) => client.createPaseoWorktree({ cwd: "/repo", worktreeSlug: "topic" }),
|
||||
(requestId: string) => ({
|
||||
type: "create_paseo_worktree_response" as const,
|
||||
payload: { requestId, workspace: null, error: null, setupTerminalId: null },
|
||||
}),
|
||||
],
|
||||
] as const)(
|
||||
"waits on %s across queued and bounded daemon stages until response or disconnect",
|
||||
async (_type, run, buildResponse) => {
|
||||
useHeartbeatClock();
|
||||
const transport = createMockTransport();
|
||||
const client = new DaemonClient({
|
||||
url: "ws://test",
|
||||
clientId: "worktree-lifecycle-wait-test",
|
||||
logger: createMockLogger(),
|
||||
reconnect: { enabled: false },
|
||||
transportFactory: () => transport.transport,
|
||||
});
|
||||
clients.push(client);
|
||||
|
||||
const connecting = client.connect();
|
||||
transport.triggerOpen();
|
||||
await connecting;
|
||||
|
||||
const pending = run(client);
|
||||
const sentFrame = JSON.parse(assertStr(transport.sent.at(-1))) as {
|
||||
message: { requestId: string };
|
||||
};
|
||||
let settled = false;
|
||||
void pending.then(
|
||||
() => {
|
||||
settled = true;
|
||||
return undefined;
|
||||
},
|
||||
() => {
|
||||
settled = true;
|
||||
return undefined;
|
||||
},
|
||||
);
|
||||
await vi.advanceTimersByTimeAsync(200_000);
|
||||
await Promise.resolve();
|
||||
expect(settled).toBe(false);
|
||||
|
||||
transport.triggerMessage(wrapSessionMessage(buildResponse(sentFrame.message.requestId)));
|
||||
await expect(pending).resolves.not.toThrow();
|
||||
|
||||
const disconnected = run(client);
|
||||
transport.triggerClose({ code: 1006, reason: "gone" });
|
||||
await expect(disconnected).rejects.toMatchObject({ code: "DAEMON_CONNECTION_LOST" });
|
||||
},
|
||||
);
|
||||
|
||||
test("honors explicit fetchAgent timeout below the session RPC default", async () => {
|
||||
useHeartbeatClock();
|
||||
const logger = createMockLogger();
|
||||
|
||||
@@ -3188,6 +3188,9 @@ export class DaemonClient {
|
||||
cwd,
|
||||
},
|
||||
responseType: "open_project_response",
|
||||
// Opening a path whose checkout is currently archiving waits on the daemon checkout gate;
|
||||
// wait for the terminal response or transport disconnect instead of timing out while queued.
|
||||
timeout: 0,
|
||||
});
|
||||
}
|
||||
|
||||
@@ -3319,6 +3322,9 @@ export class DaemonClient {
|
||||
workspaceId,
|
||||
},
|
||||
responseType: "archive_workspace_response",
|
||||
// Archive may wait for a queued checkout operation and then run teardown/manager removal,
|
||||
// each bounded on the daemon; wait for the terminal response or transport disconnect.
|
||||
timeout: 0,
|
||||
});
|
||||
}
|
||||
|
||||
@@ -3841,7 +3847,9 @@ export class DaemonClient {
|
||||
type: "workspace.recovery.restore.request",
|
||||
workspaceId,
|
||||
},
|
||||
timeout: 150_000,
|
||||
// Restore may wait behind an active archive/removal before running a bounded restore stage;
|
||||
// wait for the terminal response or transport disconnect instead of timing out mid-workflow.
|
||||
timeout: 0,
|
||||
});
|
||||
if (!payload.accepted) {
|
||||
throw new Error(payload.error ?? "Workspace recovery was rejected by the host");
|
||||
@@ -3857,8 +3865,9 @@ export class DaemonClient {
|
||||
type: "workspace.archive.undo.request",
|
||||
workspaceId,
|
||||
},
|
||||
// Undoing a finished worktree archive recreates the worktree, like recovery does.
|
||||
timeout: 150_000,
|
||||
// Undo may wait for an in-flight archive to settle and then recreate the worktree;
|
||||
// wait for the terminal response or transport disconnect.
|
||||
timeout: 0,
|
||||
});
|
||||
if (!payload.accepted) {
|
||||
throw new Error(payload.error ?? "The host could not undo the workspace archive");
|
||||
@@ -5439,6 +5448,9 @@ export class DaemonClient {
|
||||
...(input.scope !== undefined ? { scope: input.scope } : {}),
|
||||
},
|
||||
responseType: "paseo_worktree_archive_response",
|
||||
// Archive may wait for a queued checkout operation and then run teardown/manager removal,
|
||||
// each bounded on the daemon; wait for the terminal response or transport disconnect.
|
||||
timeout: 0,
|
||||
});
|
||||
}
|
||||
|
||||
@@ -5462,6 +5474,10 @@ export class DaemonClient {
|
||||
...(input.githubPrNumber !== undefined ? { githubPrNumber: input.githubPrNumber } : {}),
|
||||
},
|
||||
responseType: "create_paseo_worktree_response",
|
||||
// Every daemon stage (before hooks, shared 120s manager budget, Git, after hooks) enforces
|
||||
// its own deadline, and transport heartbeats/close reject if the host drops, so wait for the
|
||||
// terminal worktree response instead of aborting prematurely mid-workflow.
|
||||
timeout: 0,
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -589,3 +589,75 @@ describe("sidebar data SDK boundary", () => {
|
||||
).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("worktree manager SDK boundary", () => {
|
||||
it("types create, remove, and restore handlers with discriminated results and cleanup", () => {
|
||||
expect(
|
||||
typeErrors(`
|
||||
import type {
|
||||
PluginServerContext,
|
||||
WorktreeManagerRegistration,
|
||||
PluginWorktreeCreateInput,
|
||||
PluginWorktreeCreateResult,
|
||||
PluginWorktreeRemoveRequest,
|
||||
PluginWorktreeRemoveResult,
|
||||
PluginWorktreeRestoreRequest,
|
||||
PluginWorktreeRestoreResult,
|
||||
} from "@getpaseo/plugin/server";
|
||||
|
||||
export default function contribute(server: PluginServerContext) {
|
||||
const manager: WorktreeManagerRegistration = {
|
||||
async create(request: PluginWorktreeCreateInput, { paseo, signal }) {
|
||||
const untrusted: boolean = request.untrusted;
|
||||
const headSha: string | undefined = request.headSha;
|
||||
void headSha;
|
||||
// @ts-expect-error untrusted is read-only
|
||||
request.untrusted = true;
|
||||
// @ts-expect-error headSha is read-only
|
||||
request.headSha = "deadbeef";
|
||||
if (request.kind === "branch-off") {
|
||||
const start: string = request.startPoint ?? request.baseRef;
|
||||
// @ts-expect-error startPoint is read-only
|
||||
request.startPoint = "other";
|
||||
if (!start || untrusted) return;
|
||||
}
|
||||
if (signal.aborted) return;
|
||||
void paseo;
|
||||
const result: PluginWorktreeCreateResult = { type: "created", path: request.path };
|
||||
return result;
|
||||
},
|
||||
async remove(request: PluginWorktreeRemoveRequest, { signal }) {
|
||||
const reason: "archive" | "rollback" = request.reason;
|
||||
const force: boolean = request.force;
|
||||
const untrusted: boolean = request.untrusted;
|
||||
// @ts-expect-error remove request fields are read-only
|
||||
request.path = "/other";
|
||||
if (!reason || !force || untrusted || signal.aborted) return;
|
||||
const result: PluginWorktreeRemoveResult = { type: "removed" };
|
||||
return result;
|
||||
},
|
||||
async restore(request: PluginWorktreeRestoreRequest) {
|
||||
const untrusted: boolean = request.untrusted;
|
||||
void untrusted;
|
||||
if (request.target.type === "commit") return;
|
||||
if (request.target.type === "from-base") {
|
||||
const base: string = request.target.baseRef;
|
||||
void base;
|
||||
}
|
||||
const result: PluginWorktreeRestoreResult = { type: "restored", path: request.path };
|
||||
return result;
|
||||
},
|
||||
};
|
||||
const dispose: () => void = server.registerWorktreeManager(manager);
|
||||
server.registerWorktreeManager({
|
||||
// @ts-expect-error create result requires discriminant
|
||||
async create() {
|
||||
return { path: "/tmp/wt" };
|
||||
},
|
||||
});
|
||||
return dispose;
|
||||
}
|
||||
`),
|
||||
).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -5,6 +5,7 @@ import type { PluginCleanup } from "../contracts.js";
|
||||
import type { ProviderRegistration } from "./provider.js";
|
||||
import type { UsageSourceRegistration } from "./usage.js";
|
||||
import type { PluginLifecycleRegistration } from "./lifecycle.js";
|
||||
import type { WorktreeManagerRegistration } from "./worktree.js";
|
||||
|
||||
export interface PluginHandlerContext {
|
||||
paseo: PaseoApi;
|
||||
@@ -64,6 +65,7 @@ export interface PluginServerContext extends PluginLifecycleRegistration {
|
||||
): void;
|
||||
registerProvider(provider: ProviderRegistration): void;
|
||||
registerUsageSource(source: UsageSourceRegistration): void;
|
||||
registerWorktreeManager(manager: WorktreeManagerRegistration): () => void;
|
||||
}
|
||||
|
||||
export type PluginServerContribution = (server: PluginServerContext) => PluginCleanup;
|
||||
|
||||
@@ -35,3 +35,14 @@ export { spawnProcess, execCommand, terminateProcess } from "./process.js";
|
||||
|
||||
export { defineAgentTool } from "./agent-tools.js";
|
||||
export type { AgentToolDefinition, AgentToolResult, AgentToolContext } from "./agent-tools.js";
|
||||
export type {
|
||||
PluginWorktreeContext,
|
||||
PluginWorktreeCreateInput,
|
||||
PluginWorktreeCreateResult,
|
||||
PluginWorktreeRemoveRequest,
|
||||
PluginWorktreeRemoveResult,
|
||||
PluginWorktreeRestoreTarget,
|
||||
PluginWorktreeRestoreRequest,
|
||||
PluginWorktreeRestoreResult,
|
||||
WorktreeManagerRegistration,
|
||||
} from "./worktree.js";
|
||||
|
||||
@@ -37,7 +37,12 @@ export type PluginWorktreeCreateRequest = {
|
||||
slug: string;
|
||||
path: string;
|
||||
} & (
|
||||
| { kind: "branch-off"; baseRef: string }
|
||||
| {
|
||||
kind: "branch-off";
|
||||
baseRef: string;
|
||||
/** Where the new branch starts when that is not `baseRef`, such as a fork's head. */
|
||||
readonly startPoint?: string;
|
||||
}
|
||||
| { kind: "checkout-branch" }
|
||||
| {
|
||||
kind: "checkout-change-request";
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
import type { PluginHookContext, PluginWorktreeCreateRequest } from "./lifecycle.js";
|
||||
|
||||
/** Context passed to worktree manager callbacks. */
|
||||
export type PluginWorktreeContext = PluginHookContext;
|
||||
|
||||
/** Resolved creation request handed to a worktree manager after `worktree.create.before`. */
|
||||
export type PluginWorktreeCreateInput = PluginWorktreeCreateRequest & {
|
||||
/** True when the worktree comes from an untrusted source such as a fork change request; skip repository-defined hooks. */
|
||||
readonly untrusted: boolean;
|
||||
/** Resolved remote head commit SHA for change-request checkouts when available. */
|
||||
readonly headSha?: string;
|
||||
};
|
||||
|
||||
/** Return `{ type: "created", path }` to claim creation, or `undefined` to decline. */
|
||||
export interface PluginWorktreeCreateResult {
|
||||
type: "created";
|
||||
path: string;
|
||||
}
|
||||
|
||||
export interface PluginWorktreeRemoveRequest {
|
||||
readonly repoRoot: string | null;
|
||||
readonly path: string;
|
||||
readonly branch: string | null;
|
||||
readonly reason: "archive" | "rollback";
|
||||
readonly force: boolean;
|
||||
/** True when the worktree came from an untrusted source such as a fork change request; skip repository-defined hooks. */
|
||||
readonly untrusted: boolean;
|
||||
}
|
||||
|
||||
/** Return `{ type: "removed" }` after removing the worktree, or `undefined` to fall back to Git. */
|
||||
export interface PluginWorktreeRemoveResult {
|
||||
type: "removed";
|
||||
}
|
||||
|
||||
export type PluginWorktreeRestoreTarget =
|
||||
| { readonly type: "branch"; readonly branch: string }
|
||||
| { readonly type: "commit"; readonly commit: string }
|
||||
| { readonly type: "from-base"; readonly branch: string; readonly baseRef: string };
|
||||
|
||||
export interface PluginWorktreeRestoreRequest {
|
||||
readonly repoRoot: string;
|
||||
/** Recorded path the worktree must be restored to. */
|
||||
readonly path: string;
|
||||
readonly target: PluginWorktreeRestoreTarget;
|
||||
readonly baseRef: string | null;
|
||||
/** True when the worktree came from an untrusted source such as a fork change request; skip repository-defined hooks. */
|
||||
readonly untrusted: boolean;
|
||||
}
|
||||
|
||||
/** Return `{ type: "restored", path }` after recreating the worktree, or `undefined` to fall back to Git. */
|
||||
export interface PluginWorktreeRestoreResult {
|
||||
type: "restored";
|
||||
path: string;
|
||||
}
|
||||
|
||||
export interface WorktreeManagerRegistration {
|
||||
create(
|
||||
request: PluginWorktreeCreateInput,
|
||||
context: PluginWorktreeContext,
|
||||
): Promise<PluginWorktreeCreateResult | void>;
|
||||
remove?(
|
||||
request: PluginWorktreeRemoveRequest,
|
||||
context: PluginWorktreeContext,
|
||||
): Promise<PluginWorktreeRemoveResult | void>;
|
||||
restore?(
|
||||
request: PluginWorktreeRestoreRequest,
|
||||
context: PluginWorktreeContext,
|
||||
): Promise<PluginWorktreeRestoreResult | void>;
|
||||
}
|
||||
@@ -90,7 +90,7 @@
|
||||
"speech:transcribe:local": "tsx scripts/transcribe-local-wav.ts",
|
||||
"test": "npm run test:unit && npm run test:integration",
|
||||
"test:unit": "vitest run --fileParallelism --exclude \"**/*.e2e.test.ts\"",
|
||||
"test:integration": "vitest run --maxWorkers=1 src/server/git-filename-diffs.e2e.test.ts src/server/daemon-e2e/checkout-diff-content.e2e.test.ts src/server/daemon-e2e/create-agent-mode.e2e.test.ts src/server/daemon-e2e/filesystem.e2e.test.ts src/server/daemon-e2e/file-download.e2e.test.ts src/server/daemon-e2e/cli-logs-follow.e2e.test.ts src/server/creation/creation.e2e.test.ts src/server/daemon-e2e/creation-status.e2e.test.ts src/server/daemon-e2e/persisted-creation-caller.e2e.test.ts src/server/daemon-e2e/terminal-workspace-sdk.e2e.test.ts src/server/daemon-e2e/terminal-worker-lifecycle.e2e.test.ts src/server/workspace-create-worktree-source.e2e.test.ts src/server/daemon-e2e/models.e2e.test.ts src/server/daemon-e2e/live-preferences.e2e.test.ts src/server/daemon-e2e/oversized-message.e2e.test.ts src/server/agent/model-catalog.e2e.test.ts src/server/plugins/plugin-paseo-api.e2e.test.ts src/server/plugins/usage-sources.e2e.test.ts src/server/plugins/lifecycle.e2e.test.ts src/server/connected-hosts/hosts.e2e.test.ts src/server/owned-subscriptions.e2e.test.ts && vitest run --maxWorkers=1 src/server/agent/providers/omp/history.e2e.test.ts src/server/daemon-e2e/git-operations.e2e.test.ts src/server/session.create-agent-worktree-autoarchive.e2e.test.ts src/server/agent/providers/opencode-bridge.local.e2e.test.ts src/server/daemon-e2e/relay-transport.e2e.test.ts -t \"merges into|creates a worktree and auto-archives both|versioned runtime|oversized attachments|connected hosts|password-protected daemon refuses|replays selected OMP history\"",
|
||||
"test:integration": "vitest run --maxWorkers=1 src/server/git-filename-diffs.e2e.test.ts src/server/daemon-e2e/checkout-diff-content.e2e.test.ts src/server/daemon-e2e/create-agent-mode.e2e.test.ts src/server/daemon-e2e/filesystem.e2e.test.ts src/server/daemon-e2e/file-download.e2e.test.ts src/server/daemon-e2e/cli-logs-follow.e2e.test.ts src/server/creation/creation.e2e.test.ts src/server/daemon-e2e/creation-status.e2e.test.ts src/server/daemon-e2e/persisted-creation-caller.e2e.test.ts src/server/daemon-e2e/terminal-workspace-sdk.e2e.test.ts src/server/daemon-e2e/terminal-worker-lifecycle.e2e.test.ts src/server/workspace-create-worktree-source.e2e.test.ts src/server/daemon-e2e/models.e2e.test.ts src/server/daemon-e2e/live-preferences.e2e.test.ts src/server/daemon-e2e/oversized-message.e2e.test.ts src/server/agent/model-catalog.e2e.test.ts src/server/plugins/plugin-paseo-api.e2e.test.ts src/server/plugins/usage-sources.e2e.test.ts src/server/plugins/lifecycle.e2e.test.ts src/server/plugins/worktree-manager.e2e.test.ts src/server/connected-hosts/hosts.e2e.test.ts src/server/owned-subscriptions.e2e.test.ts && vitest run --maxWorkers=1 src/server/agent/providers/omp/history.e2e.test.ts src/server/daemon-e2e/git-operations.e2e.test.ts src/server/session.create-agent-worktree-autoarchive.e2e.test.ts src/server/agent/providers/opencode-bridge.local.e2e.test.ts src/server/daemon-e2e/relay-transport.e2e.test.ts -t \"merges into|creates a worktree and auto-archives both|versioned runtime|oversized attachments|connected hosts|password-protected daemon refuses|replays selected OMP history\"",
|
||||
"test:hub-cli-contract": "vitest run --maxWorkers=1 src/server/hub/hub-cli-contract.test.ts",
|
||||
"test:integration:all": "npm run test:e2e",
|
||||
"test:integration:real": "vitest run real.e2e.test.ts",
|
||||
|
||||
@@ -4,7 +4,11 @@ import type pino from "pino";
|
||||
|
||||
import type { ForgeService } from "../../services/forge-service.js";
|
||||
import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
|
||||
import { archiveByScope, type ActiveWorkspaceRef } from "../workspace-archive-service.js";
|
||||
import {
|
||||
archiveByScope,
|
||||
type ActiveWorkspaceRef,
|
||||
type ArchiveDependencies,
|
||||
} from "../workspace-archive-service.js";
|
||||
import type {
|
||||
CreatePaseoWorktreeWorkflowFn,
|
||||
CreatePaseoWorktreeWorkflowResult,
|
||||
@@ -17,10 +21,15 @@ import type {
|
||||
} from "../messages.js";
|
||||
import type { AgentManager, AgentSubscriber, SubscribeOptions } from "./agent-manager.js";
|
||||
import type { AgentStorage } from "./agent-storage.js";
|
||||
import type { PluginWorktreeManagerRuntime } from "../plugins/runtime.js";
|
||||
|
||||
interface CreateAgentLifecycleDispatchDependencies {
|
||||
paseoHome: string;
|
||||
worktreesRoot?: string;
|
||||
worktreeManagers?: Pick<PluginWorktreeManagerRuntime, "removeWorktree">;
|
||||
workspaceArchiveOperations?: ArchiveDependencies["workspaceArchiveOperations"];
|
||||
getWorkspace?: ArchiveDependencies["getWorkspace"];
|
||||
isCheckoutUntrusted?: ArchiveDependencies["isCheckoutUntrusted"];
|
||||
agentManager: AgentManager;
|
||||
agentStorage: AgentStorage;
|
||||
github: ForgeService;
|
||||
@@ -184,11 +193,15 @@ export class CreateAgentLifecycleDispatch {
|
||||
{
|
||||
paseoHome: this.dependencies.paseoHome,
|
||||
paseoWorktreesBaseRoot: this.dependencies.worktreesRoot,
|
||||
worktreeManagers: this.dependencies.worktreeManagers,
|
||||
workspaceArchiveOperations: this.dependencies.workspaceArchiveOperations,
|
||||
github: this.dependencies.github,
|
||||
workspaceGitService: this.dependencies.workspaceGitService,
|
||||
agentManager: this.dependencies.agentManager,
|
||||
agentStorage: this.dependencies.agentStorage,
|
||||
findWorkspaceIdForCwd: this.dependencies.findWorkspaceIdForCwd,
|
||||
getWorkspace: this.dependencies.getWorkspace,
|
||||
isCheckoutUntrusted: this.dependencies.isCheckoutUntrusted,
|
||||
listActiveWorkspaces: this.dependencies.listActiveWorkspaces,
|
||||
archiveWorkspaceRecord: this.dependencies.archiveWorkspaceRecord,
|
||||
emitWorkspaceUpdatesForWorkspaceIds: this.dependencies.emitWorkspaceUpdatesForWorkspaceIds,
|
||||
|
||||
@@ -139,6 +139,9 @@ export interface PaseoToolHostDependencies {
|
||||
"getSnapshot" | "listWorktrees" | "resolveRepoRoot" | "invalidateWorktrees"
|
||||
>;
|
||||
findWorkspaceIdForCwd?: ArchiveDependencies["findWorkspaceIdForCwd"];
|
||||
worktreeManagers?: ArchiveDependencies["worktreeManagers"];
|
||||
workspaceArchiveOperations?: ArchiveDependencies["workspaceArchiveOperations"];
|
||||
isCheckoutUntrusted?: ArchiveDependencies["isCheckoutUntrusted"];
|
||||
listActiveWorkspaces?: ArchiveDependencies["listActiveWorkspaces"];
|
||||
archiveWorkspaceRecord?: ArchiveDependencies["archiveWorkspaceRecord"];
|
||||
emitWorkspaceUpdatesForWorkspaceIds?: ArchiveDependencies["emitWorkspaceUpdatesForWorkspaceIds"];
|
||||
@@ -3409,11 +3412,17 @@ function archiveWorktreeDependencies(
|
||||
return {
|
||||
paseoHome: options.paseoHome,
|
||||
paseoWorktreesBaseRoot: options.worktreesRoot,
|
||||
worktreeManagers: options.worktreeManagers,
|
||||
workspaceArchiveOperations: options.workspaceArchiveOperations,
|
||||
isCheckoutUntrusted: options.isCheckoutUntrusted,
|
||||
github: options.github,
|
||||
workspaceGitService: options.workspaceGitService,
|
||||
agentManager: context.agentManager,
|
||||
agentStorage: context.agentStorage,
|
||||
findWorkspaceIdForCwd: options.findWorkspaceIdForCwd,
|
||||
...(options.workspaceRegistry
|
||||
? { getWorkspace: (workspaceId: string) => options.workspaceRegistry!.get(workspaceId) }
|
||||
: {}),
|
||||
listActiveWorkspaces: options.listActiveWorkspaces,
|
||||
archiveWorkspaceRecord: options.archiveWorkspaceRecord,
|
||||
emitWorkspaceUpdatesForWorkspaceIds: options.emitWorkspaceUpdatesForWorkspaceIds,
|
||||
|
||||
@@ -6,6 +6,7 @@ import type { DaemonConfigStore } from "../daemon-config-store.js";
|
||||
import {
|
||||
archiveByScope,
|
||||
type ActiveWorkspaceRef,
|
||||
type ArchiveDependencies,
|
||||
killTerminalsForWorkspace,
|
||||
} from "../workspace-archive-service.js";
|
||||
import type {
|
||||
@@ -16,10 +17,15 @@ import type { ForgeService } from "../../services/forge-service.js";
|
||||
import type { TerminalManager } from "../../terminal/terminal-manager.js";
|
||||
import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
|
||||
import type { WorkspaceArchiveContext } from "../workspace-registry.js";
|
||||
import type { PluginWorktreeManagerRuntime } from "../plugins/runtime.js";
|
||||
|
||||
export interface AutoArchiveArchiveOptions {
|
||||
paseoHome: string;
|
||||
paseoWorktreesBaseRoot?: string;
|
||||
worktreeManagers?: Pick<PluginWorktreeManagerRuntime, "removeWorktree">;
|
||||
workspaceArchiveOperations?: ArchiveDependencies["workspaceArchiveOperations"];
|
||||
getWorkspace?: ArchiveDependencies["getWorkspace"];
|
||||
isCheckoutUntrusted?: ArchiveDependencies["isCheckoutUntrusted"];
|
||||
daemonConfigStore: DaemonConfigStore;
|
||||
workspaceGitService: WorkspaceGitServiceImpl;
|
||||
github: ForgeService;
|
||||
@@ -99,11 +105,15 @@ export async function archiveIfSafe(input: {
|
||||
{
|
||||
paseoHome: options.paseoHome,
|
||||
paseoWorktreesBaseRoot: options.paseoWorktreesBaseRoot,
|
||||
worktreeManagers: options.worktreeManagers,
|
||||
workspaceArchiveOperations: options.workspaceArchiveOperations,
|
||||
github: options.github,
|
||||
workspaceGitService: options.workspaceGitService,
|
||||
agentManager: options.agentManager,
|
||||
agentStorage: options.agentStorage,
|
||||
findWorkspaceIdForCwd: options.findWorkspaceIdForCwd,
|
||||
getWorkspace: options.getWorkspace,
|
||||
isCheckoutUntrusted: options.isCheckoutUntrusted,
|
||||
listActiveWorkspaces: options.listActiveWorkspaces,
|
||||
archiveWorkspaceRecord: (workspaceIdToArchive, archivedAt) =>
|
||||
options.archiveWorkspaceRecord(
|
||||
|
||||
@@ -181,6 +181,7 @@ import {
|
||||
killTerminalsForWorkspace,
|
||||
type ActiveWorkspaceRef,
|
||||
} from "./workspace-archive-service.js";
|
||||
import { WorkspaceArchiveOperations } from "./workspace-archive-operations.js";
|
||||
import { setupAutoArchiveOnMerge } from "./auto-archive-on-merge/index.js";
|
||||
import { wrapSessionMessage, type SessionOutboundMessage } from "./messages.js";
|
||||
import type { TerminalManager } from "../terminal/terminal-manager.js";
|
||||
@@ -211,7 +212,10 @@ import { ScriptHealthMonitor } from "./script-health-monitor.js";
|
||||
import { createScriptStatusEmitter } from "./script-status-projection.js";
|
||||
import { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
|
||||
import { createWorkspaceScriptsService } from "./session/workspace-scripts/workspace-scripts-service.js";
|
||||
import { assertWorkspaceAutomationAllowedForWorkspace } from "./workspace-automation-gate.js";
|
||||
import {
|
||||
assertWorkspaceAutomationAllowedForWorkspace,
|
||||
isCheckoutUntrusted,
|
||||
} from "./workspace-automation-gate.js";
|
||||
import { spawnWorkspaceScript } from "./worktree-bootstrap.js";
|
||||
import {
|
||||
createManagedProcessRegistry,
|
||||
@@ -740,6 +744,7 @@ export async function createPaseoDaemon(
|
||||
});
|
||||
const scriptRuntimeStore = new WorkspaceScriptRuntimeStore();
|
||||
const workspaceSetupRuntime = new WorkspaceSetupRuntime();
|
||||
const workspaceArchiveOperations = new WorkspaceArchiveOperations();
|
||||
let configuredHostnames = config.hostnames ?? config.allowedHosts;
|
||||
let appBaseUrl = config.appBaseUrl ?? "https://app.paseo.sh";
|
||||
daemonConfigStore.onFieldChange("hostnames", (value) => {
|
||||
@@ -1160,6 +1165,8 @@ export async function createPaseoDaemon(
|
||||
worktreeRoot: workspace.worktreeRoot,
|
||||
isPaseoOwnedWorktree: workspace.isPaseoOwnedWorktree,
|
||||
mainRepoRoot: workspace.mainRepoRoot,
|
||||
worktreeManagerPluginId: workspace.worktreeManagerPluginId,
|
||||
untrustedSource: workspace.untrustedSource,
|
||||
}));
|
||||
};
|
||||
const markWorkspaceArchivingExternal = (workspaceIds: Iterable<string>, archivingAt: string) => {
|
||||
@@ -1218,6 +1225,8 @@ export async function createPaseoDaemon(
|
||||
setupAutoArchiveOnMerge({
|
||||
paseoHome: config.paseoHome,
|
||||
paseoWorktreesBaseRoot: config.worktreesRoot,
|
||||
worktreeManagers: pluginRuntime,
|
||||
workspaceArchiveOperations,
|
||||
daemonConfigStore,
|
||||
workspaceGitService,
|
||||
github,
|
||||
@@ -1226,6 +1235,8 @@ export async function createPaseoDaemon(
|
||||
terminalManager,
|
||||
logger,
|
||||
findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
|
||||
getWorkspace: (workspaceId) => workspaceRegistry.get(workspaceId),
|
||||
isCheckoutUntrusted: (checkoutPath) => isCheckoutUntrusted(workspaceRegistry, checkoutPath),
|
||||
listActiveWorkspaces: listActiveWorkspacesExternal,
|
||||
getAutoArchivedChangeRequestUrl: async (workspaceId) =>
|
||||
(await workspaceRegistry.get(workspaceId))?.autoArchivedChangeRequestUrl ?? null,
|
||||
@@ -1246,6 +1257,7 @@ export async function createPaseoDaemon(
|
||||
createPaseoWorktree: async (workflowInput, workflowOptions) => {
|
||||
return createRegisteredPaseoWorktree(workflowInput, {
|
||||
lifecycle: pluginRuntime,
|
||||
worktreeManagers: pluginRuntime,
|
||||
github,
|
||||
...(workflowOptions?.resolveDefaultBranch
|
||||
? {
|
||||
@@ -1306,6 +1318,8 @@ export async function createPaseoDaemon(
|
||||
{
|
||||
paseoHome: config.paseoHome,
|
||||
paseoWorktreesBaseRoot: config.worktreesRoot,
|
||||
worktreeManagers: pluginRuntime,
|
||||
workspaceArchiveOperations,
|
||||
github,
|
||||
workspaceGitService,
|
||||
agentManager,
|
||||
@@ -1323,6 +1337,7 @@ export async function createPaseoDaemon(
|
||||
stopWorkspaceSetup: (workspaceIdToStop) => workspaceSetupRuntime.stop(workspaceIdToStop),
|
||||
assertWorkspaceAutomationAllowed: (guardedWorkspaceId) =>
|
||||
assertWorkspaceAutomationAllowedForWorkspace(workspaceRegistry, guardedWorkspaceId),
|
||||
isCheckoutUntrusted: (checkoutPath) => isCheckoutUntrusted(workspaceRegistry, checkoutPath),
|
||||
sessionLogger: logger,
|
||||
},
|
||||
{ scope: { kind: "workspace", workspaceId }, requestId },
|
||||
@@ -1330,6 +1345,10 @@ export async function createPaseoDaemon(
|
||||
const hubAgentLifecycle = new CreateAgentLifecycleDispatch({
|
||||
paseoHome: config.paseoHome,
|
||||
worktreesRoot: config.worktreesRoot,
|
||||
worktreeManagers: pluginRuntime,
|
||||
workspaceArchiveOperations,
|
||||
getWorkspace: (workspaceId) => workspaceRegistry.get(workspaceId),
|
||||
isCheckoutUntrusted: (checkoutPath) => isCheckoutUntrusted(workspaceRegistry, checkoutPath),
|
||||
agentManager,
|
||||
agentStorage,
|
||||
github,
|
||||
@@ -1428,6 +1447,8 @@ export async function createPaseoDaemon(
|
||||
{
|
||||
paseoHome: config.paseoHome,
|
||||
paseoWorktreesBaseRoot: config.worktreesRoot,
|
||||
worktreeManagers: pluginRuntime,
|
||||
workspaceArchiveOperations,
|
||||
github,
|
||||
workspaceGitService,
|
||||
agentManager,
|
||||
@@ -1451,6 +1472,7 @@ export async function createPaseoDaemon(
|
||||
stopWorkspaceSetup: (workspaceIdToStop) => workspaceSetupRuntime.stop(workspaceIdToStop),
|
||||
assertWorkspaceAutomationAllowed: (guardedWorkspaceId) =>
|
||||
assertWorkspaceAutomationAllowedForWorkspace(workspaceRegistry, guardedWorkspaceId),
|
||||
isCheckoutUntrusted: (checkoutPath) => isCheckoutUntrusted(workspaceRegistry, checkoutPath),
|
||||
sessionLogger: logger,
|
||||
},
|
||||
{
|
||||
@@ -1577,6 +1599,9 @@ export async function createPaseoDaemon(
|
||||
daemonConfigStore,
|
||||
github,
|
||||
workspaceGitService,
|
||||
worktreeManagers: pluginRuntime,
|
||||
workspaceArchiveOperations,
|
||||
isCheckoutUntrusted: (checkoutPath) => isCheckoutUntrusted(workspaceRegistry, checkoutPath),
|
||||
findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
|
||||
listActiveWorkspaces: listActiveWorkspacesExternal,
|
||||
archiveWorkspaceRecord: (workspaceId, archivedAt) =>
|
||||
@@ -1924,6 +1949,7 @@ export async function createPaseoDaemon(
|
||||
pluginRuntime,
|
||||
orchestrationSkills,
|
||||
workspaceLabelService,
|
||||
workspaceArchiveOperations,
|
||||
);
|
||||
pluginRuntime.bindPaseoSessionHost(wsServer);
|
||||
await pluginRuntime.start();
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
import type { JsonValue } from "@getpaseo/protocol/agent-types";
|
||||
import type { PluginLifecycle } from "./plugins/lifecycle/index.js";
|
||||
import type { PluginWorktreeManagerRuntime } from "./plugins/runtime.js";
|
||||
import { stat } from "node:fs/promises";
|
||||
import { resolve } from "node:path";
|
||||
|
||||
@@ -63,6 +64,10 @@ export interface AttemptFirstAgentBranchAutoNameResult {
|
||||
|
||||
export interface CreatePaseoWorktreeDeps extends CreateWorktreeCoreDeps {
|
||||
lifecycle?: Pick<PluginLifecycle, "wait" | "before">;
|
||||
worktreeManagers?: Pick<
|
||||
PluginWorktreeManagerRuntime,
|
||||
"hasWorktreeManager" | "createWorktree" | "removeWorktree"
|
||||
>;
|
||||
workspaceGitService: WorkspaceGitService;
|
||||
workspaceProvisioning: Pick<WorkspaceProvisioningService, "createWorkspaceForWorktree">;
|
||||
}
|
||||
@@ -114,22 +119,13 @@ async function createPaseoWorktreeWithPriority(
|
||||
worktreeRoot: createdWorktree.worktree.worktreePath,
|
||||
branch: createdWorktree.worktree.branchName || null,
|
||||
baseBranch: createdWorktree.worktree.comparisonBaseRef,
|
||||
worktreeManagerPluginId: createdWorktree.worktree.worktreeManagerPluginId ?? null,
|
||||
title: input.title?.trim() || resolveFirstAgentPromptTitle(input.firstAgentContext),
|
||||
metadata: input.metadata,
|
||||
expectsInitialAgent: Boolean(input.firstAgentContext),
|
||||
background: input.background,
|
||||
callerWorkspaceId: input.callerWorkspaceId,
|
||||
...(createdWorktree.intent.kind === "checkout-change-request" &&
|
||||
createdWorktree.intent.headRepository
|
||||
? {
|
||||
untrustedSource: {
|
||||
kind: "change_request" as const,
|
||||
forge: createdWorktree.intent.forge,
|
||||
number: createdWorktree.intent.changeRequestNumber,
|
||||
headRepository: createdWorktree.intent.headRepository,
|
||||
},
|
||||
}
|
||||
: {}),
|
||||
untrustedSource: createdWorktree.untrustedSource,
|
||||
});
|
||||
|
||||
deps.github.invalidate({ cwd: createdWorktree.worktree.worktreePath });
|
||||
@@ -152,6 +148,10 @@ async function createPaseoWorktreeWithPriority(
|
||||
teardownCwds: [],
|
||||
paseoHome: input.paseoHome,
|
||||
worktreesBaseRoot: input.worktreesRoot,
|
||||
worktreeManagers: deps.worktreeManagers,
|
||||
worktreeManagerPluginId: createdWorktree.worktree.worktreeManagerPluginId ?? null,
|
||||
removeReason: "rollback",
|
||||
untrusted: Boolean(createdWorktree.untrustedSource),
|
||||
},
|
||||
error,
|
||||
);
|
||||
@@ -286,6 +286,10 @@ async function maybeMarkFirstAgentBranchAutoNameEligible(options: {
|
||||
if (!createdWorktree.created || createdWorktree.intent.kind !== "branch-off") {
|
||||
return;
|
||||
}
|
||||
// A worktree manager plugin owns branch and directory naming, so skip silent renames.
|
||||
if (createdWorktree.worktree.worktreeManagerPluginId) {
|
||||
return;
|
||||
}
|
||||
// A branch the caller named is their choice; only a placeholder slug is replaced.
|
||||
if (input.branchName !== undefined) {
|
||||
return;
|
||||
|
||||
@@ -24,7 +24,7 @@ import { type ManagedPluginCandidate, ManagedPluginSources } from "./managed-sou
|
||||
import { readPluginManifest } from "./manifest.js";
|
||||
import { expandTilde } from "../../utils/path.js";
|
||||
import { runPluginBuild } from "./preparation.js";
|
||||
import { PluginRuntime } from "./runtime.js";
|
||||
import { PluginRuntime, type PluginWorktreeManagerRuntime } from "./runtime.js";
|
||||
import type { PluginRuntimeSubscription } from "./runtime-subscription.js";
|
||||
import { BuiltinPluginLoader, type BuiltinPlugin } from "./builtin/index.js";
|
||||
import type {
|
||||
@@ -50,6 +50,10 @@ interface PluginRuntimePort {
|
||||
drainEvents?: PluginRuntime["drainEvents"];
|
||||
before?: PluginLifecycle["before"];
|
||||
wait?: PluginLifecycle["wait"];
|
||||
hasWorktreeManager?: PluginWorktreeManagerRuntime["hasWorktreeManager"];
|
||||
createWorktree?: PluginWorktreeManagerRuntime["createWorktree"];
|
||||
removeWorktree?: PluginWorktreeManagerRuntime["removeWorktree"];
|
||||
restoreWorktree?: PluginWorktreeManagerRuntime["restoreWorktree"];
|
||||
catalog: PluginRuntime["catalog"];
|
||||
invoke(pluginId: string, method: string, input: unknown): Promise<unknown>;
|
||||
startSubscription: PluginRuntime["startSubscription"];
|
||||
@@ -192,6 +196,31 @@ export class PluginService {
|
||||
return request;
|
||||
};
|
||||
|
||||
readonly hasWorktreeManager: PluginWorktreeManagerRuntime["hasWorktreeManager"] = (options) => {
|
||||
return this.runtime.hasWorktreeManager?.(options) ?? false;
|
||||
};
|
||||
|
||||
readonly createWorktree: PluginWorktreeManagerRuntime["createWorktree"] = async (
|
||||
request,
|
||||
options,
|
||||
) => {
|
||||
return (await this.runtime.createWorktree?.(request, options)) ?? null;
|
||||
};
|
||||
|
||||
readonly removeWorktree: PluginWorktreeManagerRuntime["removeWorktree"] = async (
|
||||
request,
|
||||
options,
|
||||
) => {
|
||||
return (await this.runtime.removeWorktree?.(request, options)) ?? null;
|
||||
};
|
||||
|
||||
readonly restoreWorktree: PluginWorktreeManagerRuntime["restoreWorktree"] = async (
|
||||
request,
|
||||
options,
|
||||
) => {
|
||||
return (await this.runtime.restoreWorktree?.(request, options)) ?? null;
|
||||
};
|
||||
|
||||
subscribeSettings(listener: (pluginId: string, settingsId: string) => void): () => void {
|
||||
this.settingsListeners.add(listener);
|
||||
return () => this.settingsListeners.delete(listener);
|
||||
|
||||
@@ -57,7 +57,12 @@ const changeRequestFields = {
|
||||
};
|
||||
const worktreeRequestSchema = z.discriminatedUnion("kind", [
|
||||
z
|
||||
.object({ ...worktreeRequestFields, kind: z.literal("branch-off"), baseRef: z.string().min(1) })
|
||||
.object({
|
||||
...worktreeRequestFields,
|
||||
kind: z.literal("branch-off"),
|
||||
baseRef: z.string().min(1),
|
||||
startPoint: z.string().min(1).optional(),
|
||||
})
|
||||
.strict(),
|
||||
z
|
||||
.object({
|
||||
@@ -239,6 +244,28 @@ function changesSessionOpenTarget(previous: SessionOpenRequest, next: SessionOpe
|
||||
);
|
||||
}
|
||||
|
||||
type WorktreeBeforeRequest = z.infer<(typeof beforeSchemas)["worktree.create.before"]>;
|
||||
|
||||
function validateWorktreeBeforeResult(
|
||||
previous: WorktreeBeforeRequest,
|
||||
next: WorktreeBeforeRequest,
|
||||
): WorktreeBeforeRequest {
|
||||
if (previous.repoRoot !== next.repoRoot || previous.sourceCheckout !== next.sourceCheckout) {
|
||||
throw new Error("worktree.create.before hooks cannot change repoRoot or sourceCheckout");
|
||||
}
|
||||
if (previous.kind === "branch-off" && next.kind === "branch-off") {
|
||||
if (next.startPoint !== undefined && next.startPoint !== previous.startPoint) {
|
||||
throw new Error("worktree.create.before hooks cannot change startPoint");
|
||||
}
|
||||
if (next.startPoint === undefined && previous.startPoint !== undefined) {
|
||||
return { ...next, startPoint: previous.startPoint };
|
||||
}
|
||||
} else if (next.kind === "branch-off" && next.startPoint !== undefined) {
|
||||
throw new Error("worktree.create.before hooks cannot change startPoint");
|
||||
}
|
||||
return next;
|
||||
}
|
||||
|
||||
export async function validateBeforeResult<Name extends keyof PluginWireBeforeRequests>(
|
||||
name: Name,
|
||||
input: PluginWireBeforeRequests[Name],
|
||||
@@ -280,9 +307,7 @@ export async function validateBeforeResult<Name extends keyof PluginWireBeforeRe
|
||||
if (name === "worktree.create.before") {
|
||||
const previous = beforeSchemas["worktree.create.before"].parse(input);
|
||||
const next = beforeSchemas["worktree.create.before"].parse(result);
|
||||
if (previous.repoRoot !== next.repoRoot || previous.sourceCheckout !== next.sourceCheckout) {
|
||||
throw new Error("worktree.create.before hooks cannot change repoRoot or sourceCheckout");
|
||||
}
|
||||
return validateWorktreeBeforeResult(previous, next) as PluginWireBeforeRequests[Name];
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -45,6 +45,11 @@ export interface PluginUsageSourceMetadata {
|
||||
icon?: string;
|
||||
}
|
||||
|
||||
export interface PluginWorktreeManagerCapabilities {
|
||||
hasRemove: boolean;
|
||||
hasRestore: boolean;
|
||||
}
|
||||
|
||||
export type PluginProcessRequest =
|
||||
| { type: "tool.call"; requestId: string; agent: PluginHookAgent; name: string; input: unknown }
|
||||
| { type: "tool.cancel"; requestId: string }
|
||||
@@ -84,6 +89,10 @@ export type PluginProcessRequest =
|
||||
}
|
||||
| { type: "hook"; requestId: string; name: string; input: unknown }
|
||||
| { type: "hook.cancel"; requestId: string }
|
||||
| { type: "worktree.create"; requestId: string; request: unknown }
|
||||
| { type: "worktree.remove"; requestId: string; request: unknown }
|
||||
| { type: "worktree.restore"; requestId: string; request: unknown }
|
||||
| { type: "worktree.cancel"; requestId: string }
|
||||
| { type: "usage.fetch"; requestId: string; sourceId: string; input: unknown }
|
||||
| { type: "usage.discover"; requestId: string; sourceId: string; scope: UsageScope }
|
||||
| { type: "invoke"; requestId: string; method: string; input: unknown }
|
||||
@@ -115,6 +124,10 @@ export type PluginProcessRequest =
|
||||
export type PluginProcessMessage =
|
||||
| { type: "settings.changed"; settingsId: string }
|
||||
| { type: "hooks.changed"; hooks: string[] }
|
||||
| {
|
||||
type: "worktree_manager.changed";
|
||||
worktreeManager: PluginWorktreeManagerCapabilities | null;
|
||||
}
|
||||
| {
|
||||
type: "ready";
|
||||
methods: string[];
|
||||
@@ -122,6 +135,7 @@ export type PluginProcessMessage =
|
||||
providers: PluginProviderMetadata[];
|
||||
usageSources?: PluginUsageSourceMetadata[];
|
||||
hooks?: string[];
|
||||
worktreeManager?: PluginWorktreeManagerCapabilities | null;
|
||||
}
|
||||
| { type: "result"; requestId: string; output: unknown }
|
||||
| { type: "error"; requestId: string; error: string }
|
||||
@@ -149,6 +163,12 @@ export type PluginProcessMessage =
|
||||
| { type: "paseo_close" };
|
||||
|
||||
const hooksSchema = z.array(z.string());
|
||||
const worktreeManagerCapabilitiesSchema = z
|
||||
.object({
|
||||
hasRemove: z.boolean(),
|
||||
hasRestore: z.boolean(),
|
||||
})
|
||||
.strict();
|
||||
|
||||
const providerMetadataSchema = z
|
||||
.object({
|
||||
@@ -294,6 +314,14 @@ export const PluginProcessRequestSchema: z.ZodType<PluginProcessRequest> = z.dis
|
||||
})
|
||||
.strict(),
|
||||
z.object({ type: z.literal("hook.cancel"), requestId: z.string() }).strict(),
|
||||
z
|
||||
.object({
|
||||
type: z.enum(["worktree.create", "worktree.remove", "worktree.restore"]),
|
||||
requestId: z.string().min(1),
|
||||
request: z.unknown(),
|
||||
})
|
||||
.strict(),
|
||||
z.object({ type: z.literal("worktree.cancel"), requestId: z.string().min(1) }).strict(),
|
||||
z
|
||||
.object({
|
||||
type: z.literal("usage.fetch"),
|
||||
@@ -356,6 +384,12 @@ export const PluginProcessMessageSchema: z.ZodType<PluginProcessMessage> = z.dis
|
||||
[
|
||||
z.object({ type: z.literal("settings.changed"), settingsId: z.string() }).strict(),
|
||||
z.object({ type: z.literal("hooks.changed"), hooks: hooksSchema }).strict(),
|
||||
z
|
||||
.object({
|
||||
type: z.literal("worktree_manager.changed"),
|
||||
worktreeManager: worktreeManagerCapabilitiesSchema.nullable(),
|
||||
})
|
||||
.strict(),
|
||||
z
|
||||
.object({
|
||||
type: z.literal("ready"),
|
||||
@@ -364,6 +398,7 @@ export const PluginProcessMessageSchema: z.ZodType<PluginProcessMessage> = z.dis
|
||||
providers: z.array(providerMetadataSchema),
|
||||
usageSources: z.array(usageSourceMetadataSchema).optional(),
|
||||
hooks: hooksSchema.optional(),
|
||||
worktreeManager: worktreeManagerCapabilitiesSchema.nullable().optional(),
|
||||
})
|
||||
.strict(),
|
||||
z
|
||||
|
||||
@@ -16,6 +16,10 @@ import type {
|
||||
PluginHandlerContext,
|
||||
PluginServerContext,
|
||||
PluginServerContribution,
|
||||
PluginWorktreeCreateInput,
|
||||
PluginWorktreeRemoveRequest,
|
||||
PluginWorktreeRestoreRequest,
|
||||
WorktreeManagerRegistration,
|
||||
} from "@getpaseo/plugin/server";
|
||||
import { assertPluginWireValue } from "@getpaseo/protocol/binary-frames/index";
|
||||
import {
|
||||
@@ -115,6 +119,8 @@ export function createPluginWorker(options: {
|
||||
const subscriptions = new PluginSubscriptionHandlers({ send, sendAndWait });
|
||||
const providers = new Map<string, ProviderRegistration>();
|
||||
const usageSources = new Map<string, UsageSourceRegistration>();
|
||||
let worktreeManager: WorktreeManagerRegistration | null = null;
|
||||
const worktreeRequests = new Map<string, AbortController>();
|
||||
const providerConnections = new Map<
|
||||
string,
|
||||
{ connection: ProviderConnection; unsubscribe: () => void; closing?: Promise<void> }
|
||||
@@ -228,6 +234,36 @@ export function createPluginWorker(options: {
|
||||
usageSources.set(id, { ...source, id });
|
||||
}
|
||||
|
||||
function worktreeManagerCapabilities() {
|
||||
if (!worktreeManager) return null;
|
||||
return {
|
||||
hasRemove: worktreeManager.remove !== undefined,
|
||||
hasRestore: worktreeManager.restore !== undefined,
|
||||
};
|
||||
}
|
||||
|
||||
function registerWorktreeManager(manager: WorktreeManagerRegistration): () => void {
|
||||
if (!manager || typeof manager.create !== "function") {
|
||||
throw new Error("Plugin worktree manager must implement create()");
|
||||
}
|
||||
if (manager.remove !== undefined && typeof manager.remove !== "function") {
|
||||
throw new Error("Invalid remove callback for plugin worktree manager");
|
||||
}
|
||||
if (manager.restore !== undefined && typeof manager.restore !== "function") {
|
||||
throw new Error("Invalid restore callback for plugin worktree manager");
|
||||
}
|
||||
if (worktreeManager !== null) {
|
||||
throw new Error("Plugin already registered a worktree manager");
|
||||
}
|
||||
worktreeManager = manager;
|
||||
send({ type: "worktree_manager.changed", worktreeManager: worktreeManagerCapabilities() });
|
||||
return () => {
|
||||
if (worktreeManager !== manager) return;
|
||||
worktreeManager = null;
|
||||
send({ type: "worktree_manager.changed", worktreeManager: null });
|
||||
};
|
||||
}
|
||||
|
||||
function providerMetadata(provider: ProviderRegistration) {
|
||||
return {
|
||||
id: provider.id,
|
||||
@@ -433,6 +469,7 @@ export function createPluginWorker(options: {
|
||||
handle,
|
||||
registerProvider,
|
||||
registerUsageSource,
|
||||
registerWorktreeManager,
|
||||
registerSettings,
|
||||
addHook: hooks.addHook,
|
||||
on: hooks.on,
|
||||
@@ -459,6 +496,7 @@ export function createPluginWorker(options: {
|
||||
methods: [...handlers.keys()].sort(),
|
||||
subscriptions: subscriptions.catalog(),
|
||||
hooks: hooks.catalog(),
|
||||
worktreeManager: worktreeManagerCapabilities(),
|
||||
providers: [...providers.values()]
|
||||
.sort((left, right) => left.id.localeCompare(right.id))
|
||||
.map(providerMetadata),
|
||||
@@ -478,6 +516,8 @@ export function createPluginWorker(options: {
|
||||
for (const pending of pendingProviderConnections.values()) pending.tombstoned = true;
|
||||
for (const request of installationRequests.values())
|
||||
request.abort(new Error("Plugin is stopping"));
|
||||
for (const request of worktreeRequests.values()) request.abort(new Error("Plugin is stopping"));
|
||||
worktreeManager = null;
|
||||
const currentCleanup = cleanup;
|
||||
cleanup = null;
|
||||
try {
|
||||
@@ -519,6 +559,9 @@ export function createPluginWorker(options: {
|
||||
message.type === "provider.catalog_key" ||
|
||||
message.type === "usage.fetch" ||
|
||||
message.type === "usage.discover" ||
|
||||
message.type === "worktree.create" ||
|
||||
message.type === "worktree.remove" ||
|
||||
message.type === "worktree.restore" ||
|
||||
message.type === "subscribe"
|
||||
) {
|
||||
send({ type: "error", requestId: message.requestId, error: "Plugin is stopping" });
|
||||
@@ -704,6 +747,10 @@ export function createPluginWorker(options: {
|
||||
handleHookMessage(message);
|
||||
return;
|
||||
}
|
||||
if (isWorktreeMessage(message)) {
|
||||
handleWorktreeMessage(message);
|
||||
return;
|
||||
}
|
||||
if (message.type === "invoke") invoke(message);
|
||||
else handleSubscriptionMessage(message);
|
||||
}
|
||||
@@ -769,6 +816,88 @@ export function createPluginWorker(options: {
|
||||
): message is Extract<PluginProcessRequest, { type: "hook" | "hook.cancel" }> {
|
||||
return message.type === "hook" || message.type === "hook.cancel";
|
||||
}
|
||||
|
||||
function isWorktreeMessage(
|
||||
message: PluginProcessRequest,
|
||||
): message is Extract<
|
||||
PluginProcessRequest,
|
||||
{ type: "worktree.create" | "worktree.remove" | "worktree.restore" | "worktree.cancel" }
|
||||
> {
|
||||
return (
|
||||
message.type === "worktree.create" ||
|
||||
message.type === "worktree.remove" ||
|
||||
message.type === "worktree.restore" ||
|
||||
message.type === "worktree.cancel"
|
||||
);
|
||||
}
|
||||
|
||||
function handleWorktreeMessage(
|
||||
message: Extract<
|
||||
PluginProcessRequest,
|
||||
{ type: "worktree.create" | "worktree.remove" | "worktree.restore" | "worktree.cancel" }
|
||||
>,
|
||||
): void {
|
||||
if (message.type === "worktree.cancel") {
|
||||
worktreeRequests.get(message.requestId)?.abort(new Error("Worktree request canceled"));
|
||||
return;
|
||||
}
|
||||
if (!paseo) {
|
||||
send({
|
||||
type: "error",
|
||||
requestId: message.requestId,
|
||||
error: "Plugin Paseo API is unavailable",
|
||||
});
|
||||
return;
|
||||
}
|
||||
const manager = worktreeManager;
|
||||
if (!manager) {
|
||||
send({
|
||||
type: "error",
|
||||
requestId: message.requestId,
|
||||
error: "Plugin has no registered worktree manager",
|
||||
});
|
||||
return;
|
||||
}
|
||||
const controller = new AbortController();
|
||||
worktreeRequests.set(message.requestId, controller);
|
||||
const context = { paseo, signal: controller.signal };
|
||||
void (async () => {
|
||||
if (message.type === "worktree.create") {
|
||||
return (
|
||||
(await manager.create(
|
||||
structuredClone(message.request) as PluginWorktreeCreateInput,
|
||||
context,
|
||||
)) ?? null
|
||||
);
|
||||
}
|
||||
if (message.type === "worktree.remove") {
|
||||
if (!manager.remove) {
|
||||
throw new Error("Plugin worktree manager does not implement remove");
|
||||
}
|
||||
return (
|
||||
(await manager.remove(
|
||||
structuredClone(message.request) as PluginWorktreeRemoveRequest,
|
||||
context,
|
||||
)) ?? null
|
||||
);
|
||||
}
|
||||
if (!manager.restore) {
|
||||
throw new Error("Plugin worktree manager does not implement restore");
|
||||
}
|
||||
return (
|
||||
(await manager.restore(
|
||||
structuredClone(message.request) as PluginWorktreeRestoreRequest,
|
||||
context,
|
||||
)) ?? null
|
||||
);
|
||||
})()
|
||||
.then(
|
||||
(output) => send({ type: "result", requestId: message.requestId, output }),
|
||||
(error) =>
|
||||
send({ type: "error", requestId: message.requestId, error: describeError(error) }),
|
||||
)
|
||||
.finally(() => worktreeRequests.delete(message.requestId));
|
||||
}
|
||||
return { shutdown };
|
||||
}
|
||||
|
||||
|
||||
@@ -18,7 +18,15 @@ import {
|
||||
type ProviderStatus,
|
||||
type ProviderStatusRequest,
|
||||
} from "@getpaseo/plugin/server/provider";
|
||||
import type { PluginHookEvents, PluginHookAgent, AgentToolResult } from "@getpaseo/plugin/server";
|
||||
import type {
|
||||
PluginHookEvents,
|
||||
PluginHookAgent,
|
||||
AgentToolResult,
|
||||
PluginWorktreeCreateInput,
|
||||
PluginWorktreeRemoveRequest,
|
||||
PluginWorktreeRestoreRequest,
|
||||
} from "@getpaseo/plugin/server";
|
||||
import { z } from "zod";
|
||||
import { validateBeforeRequest, validateBeforeResult } from "./lifecycle/index.js";
|
||||
import { fork } from "node:child_process";
|
||||
import path from "node:path";
|
||||
@@ -42,6 +50,7 @@ import type {
|
||||
PluginProcessRequest,
|
||||
PluginProviderMetadata,
|
||||
PluginUsageSourceMetadata,
|
||||
PluginWorktreeManagerCapabilities,
|
||||
} from "./plugin-process-protocol.js";
|
||||
import { PluginProcessMessageSchema } from "./plugin-process-protocol.js";
|
||||
import {
|
||||
@@ -53,7 +62,40 @@ import { InternalPluginChild } from "./internal-child.js";
|
||||
import { evaluateBundle } from "./bundle-evaluator.js";
|
||||
|
||||
const REQUEST_TIMEOUT_MS = 30_000;
|
||||
const WORKTREE_MANAGER_TIMEOUT_MS = 120_000;
|
||||
const TOOL_CALL_TIMEOUT_MS = 10 * 60_000;
|
||||
|
||||
const worktreeCreateResultSchema = z
|
||||
.object({ type: z.literal("created"), path: z.string().min(1) })
|
||||
.strict()
|
||||
.nullable();
|
||||
const worktreeRemoveResultSchema = z
|
||||
.object({ type: z.literal("removed") })
|
||||
.strict()
|
||||
.nullable();
|
||||
const worktreeRestoreResultSchema = z
|
||||
.object({ type: z.literal("restored"), path: z.string().min(1) })
|
||||
.strict()
|
||||
.nullable();
|
||||
|
||||
export interface PluginWorktreeManagerRuntime {
|
||||
hasWorktreeManager(options?: {
|
||||
operation?: "create" | "remove" | "restore";
|
||||
preferredPluginId?: string;
|
||||
}): boolean;
|
||||
createWorktree(
|
||||
request: PluginWorktreeCreateInput,
|
||||
options?: { signal?: AbortSignal },
|
||||
): Promise<{ pluginId: string; path: string } | null>;
|
||||
removeWorktree(
|
||||
request: PluginWorktreeRemoveRequest,
|
||||
options?: { preferredPluginId?: string; signal?: AbortSignal },
|
||||
): Promise<{ pluginId: string } | null>;
|
||||
restoreWorktree(
|
||||
request: PluginWorktreeRestoreRequest,
|
||||
options?: { preferredPluginId?: string; signal?: AbortSignal },
|
||||
): Promise<{ pluginId: string; path: string } | null>;
|
||||
}
|
||||
const MAX_LOG_ENTRIES = 500;
|
||||
const MAX_LOG_BYTES = 256 * 1024;
|
||||
const MAX_LOG_LINE_BYTES = 16 * 1024;
|
||||
@@ -87,6 +129,8 @@ interface PluginRequestOptions {
|
||||
signal?: AbortSignal;
|
||||
/** Receives `provider.installation.report` messages for the request. */
|
||||
report?: (report: ProviderUpdateReport) => void;
|
||||
/** Overrides the default per-message timeout (e.g. shared budget across serial worktree managers). */
|
||||
timeoutMs?: number;
|
||||
}
|
||||
|
||||
interface LoadedPlugin {
|
||||
@@ -100,6 +144,7 @@ interface LoadedPlugin {
|
||||
subscriptionMethods: ReadonlySet<string>;
|
||||
subscriptions: Map<string, BufferedPluginSubscription>;
|
||||
hooks: string[];
|
||||
worktreeManager: PluginWorktreeManagerCapabilities | null;
|
||||
providers: readonly PluginProviderMetadata[];
|
||||
usageSources: readonly PluginUsageSourceMetadata[];
|
||||
child: PluginChild | null;
|
||||
@@ -293,8 +338,17 @@ function isInstallationRequest(message: PluginProcessRequest): boolean {
|
||||
);
|
||||
}
|
||||
|
||||
function isWorktreeManagerRequest(message: PluginProcessRequest): boolean {
|
||||
return (
|
||||
message.type === "worktree.create" ||
|
||||
message.type === "worktree.remove" ||
|
||||
message.type === "worktree.restore"
|
||||
);
|
||||
}
|
||||
|
||||
function requestTimeoutMs(message: PluginProcessRequest): number | null {
|
||||
if (message.type === "tool.call") return TOOL_CALL_TIMEOUT_MS;
|
||||
if (isWorktreeManagerRequest(message)) return WORKTREE_MANAGER_TIMEOUT_MS;
|
||||
// An updater runs as long as it needs; daemon shutdown aborts it.
|
||||
if (message.type === "provider.installation.update") return null;
|
||||
return REQUEST_TIMEOUT_MS;
|
||||
@@ -752,6 +806,112 @@ export class PluginRuntime {
|
||||
return request;
|
||||
}
|
||||
|
||||
hasWorktreeManager(options?: {
|
||||
operation?: "create" | "remove" | "restore";
|
||||
preferredPluginId?: string;
|
||||
}): boolean {
|
||||
const operation = options?.operation ?? "create";
|
||||
const supports = (manager: PluginWorktreeManagerCapabilities | null): boolean => {
|
||||
if (!manager) return false;
|
||||
if (operation === "remove") return manager.hasRemove;
|
||||
if (operation === "restore") return manager.hasRestore;
|
||||
return true;
|
||||
};
|
||||
if (options?.preferredPluginId) {
|
||||
return supports(this.plugins.get(options.preferredPluginId)?.worktreeManager ?? null);
|
||||
}
|
||||
for (const loaded of this.plugins.values()) {
|
||||
if (supports(loaded.worktreeManager)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
async createWorktree(
|
||||
request: PluginWorktreeCreateInput,
|
||||
options?: { signal?: AbortSignal },
|
||||
): Promise<{ pluginId: string; path: string } | null> {
|
||||
const plugins = [...this.plugins.values()]
|
||||
.filter((plugin) => plugin.worktreeManager !== null)
|
||||
.sort((left, right) => left.id.localeCompare(right.id));
|
||||
// Share one 120s budget across the full serial manager chain so clients waiting on
|
||||
// create_paseo_worktree_request (150s) never time out while the daemon is still running managers.
|
||||
const deadline = Date.now() + WORKTREE_MANAGER_TIMEOUT_MS;
|
||||
for (const loaded of plugins) {
|
||||
const remainingMs = deadline - Date.now();
|
||||
if (remainingMs <= 0) {
|
||||
throw new Error(
|
||||
`Plugin ${loaded.id} worktree.create failed: Plugin RPC timed out: ${loaded.id}.worktree.create`,
|
||||
);
|
||||
}
|
||||
try {
|
||||
const raw = await this.request(
|
||||
loaded,
|
||||
{ type: "worktree.create", requestId: randomUUID(), request },
|
||||
{ signal: options?.signal, timeoutMs: remainingMs },
|
||||
);
|
||||
const parsed = worktreeCreateResultSchema.parse(raw ?? null);
|
||||
if (parsed !== null) {
|
||||
return { pluginId: loaded.id, path: parsed.path };
|
||||
}
|
||||
} catch (error) {
|
||||
throw new Error(`Plugin ${loaded.id} worktree.create failed: ${describeError(error)}`, {
|
||||
cause: error,
|
||||
});
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
async removeWorktree(
|
||||
request: PluginWorktreeRemoveRequest,
|
||||
options?: { preferredPluginId?: string; signal?: AbortSignal },
|
||||
): Promise<{ pluginId: string } | null> {
|
||||
if (!options?.preferredPluginId) return null;
|
||||
const loaded = this.plugins.get(options.preferredPluginId);
|
||||
if (!loaded?.worktreeManager?.hasRemove) return null;
|
||||
try {
|
||||
const raw = await this.request(
|
||||
loaded,
|
||||
{ type: "worktree.remove", requestId: randomUUID(), request },
|
||||
{ signal: options.signal },
|
||||
);
|
||||
const parsed = worktreeRemoveResultSchema.parse(raw ?? null);
|
||||
if (parsed !== null) {
|
||||
return { pluginId: loaded.id };
|
||||
}
|
||||
return null;
|
||||
} catch (error) {
|
||||
throw new Error(`Plugin ${loaded.id} worktree.remove failed: ${describeError(error)}`, {
|
||||
cause: error,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
async restoreWorktree(
|
||||
request: PluginWorktreeRestoreRequest,
|
||||
options?: { preferredPluginId?: string; signal?: AbortSignal },
|
||||
): Promise<{ pluginId: string; path: string } | null> {
|
||||
if (!options?.preferredPluginId) return null;
|
||||
const loaded = this.plugins.get(options.preferredPluginId);
|
||||
if (!loaded?.worktreeManager?.hasRestore) return null;
|
||||
try {
|
||||
const raw = await this.request(
|
||||
loaded,
|
||||
{ type: "worktree.restore", requestId: randomUUID(), request },
|
||||
{ signal: options.signal },
|
||||
);
|
||||
const parsed = worktreeRestoreResultSchema.parse(raw ?? null);
|
||||
if (parsed !== null) {
|
||||
return { pluginId: loaded.id, path: parsed.path };
|
||||
}
|
||||
return null;
|
||||
} catch (error) {
|
||||
throw new Error(`Plugin ${loaded.id} worktree.restore failed: ${describeError(error)}`, {
|
||||
cause: error,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
async getProviderCatalogCacheKey(
|
||||
pluginId: string,
|
||||
providerId: string,
|
||||
@@ -853,12 +1013,14 @@ export class PluginRuntime {
|
||||
loaded.pending.delete(requestId);
|
||||
if (message.type === "tool.call")
|
||||
void send(child, { type: "tool.cancel", requestId }).catch(() => {});
|
||||
if (isWorktreeManagerRequest(message))
|
||||
void send(child, { type: "worktree.cancel", requestId }).catch(() => {});
|
||||
if (isInstallationRequest(message))
|
||||
void send(child, { type: "provider.installation.cancel", requestId }).catch(() => {});
|
||||
signal?.removeEventListener("abort", cancel);
|
||||
reject(signal?.reason ?? new Error("Tool call canceled"));
|
||||
reject(signal?.reason ?? new Error("Plugin request canceled"));
|
||||
};
|
||||
const timeoutMs = requestTimeoutMs(message);
|
||||
const timeoutMs = options.timeoutMs ?? requestTimeoutMs(message);
|
||||
const timeout =
|
||||
timeoutMs === null
|
||||
? undefined
|
||||
@@ -870,6 +1032,9 @@ export class PluginRuntime {
|
||||
if (message.type === "hook") {
|
||||
void send(child, { type: "hook.cancel", requestId }).catch(() => {});
|
||||
}
|
||||
if (isWorktreeManagerRequest(message)) {
|
||||
void send(child, { type: "worktree.cancel", requestId }).catch(() => {});
|
||||
}
|
||||
// The handler may still start after the daemon gave up on it.
|
||||
if (message.type === "subscribe") {
|
||||
const { subscriptionId } = message;
|
||||
@@ -935,6 +1100,7 @@ export class PluginRuntime {
|
||||
subscriptionMethods: new Set(),
|
||||
subscriptions: new Map(),
|
||||
hooks: [],
|
||||
worktreeManager: null,
|
||||
providers: [],
|
||||
usageSources: [],
|
||||
child: null,
|
||||
@@ -1067,6 +1233,7 @@ export class PluginRuntime {
|
||||
subscriptionMethods: new Set(ready.subscriptions ?? []),
|
||||
subscriptions: new Map(),
|
||||
hooks: ready.hooks ?? [],
|
||||
worktreeManager: ready.worktreeManager ?? null,
|
||||
providers: ready.providers ?? [],
|
||||
usageSources: ready.usageSources ?? [],
|
||||
child,
|
||||
@@ -1156,6 +1323,10 @@ export class PluginRuntime {
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (message.type === "worktree_manager.changed") {
|
||||
loaded.worktreeManager = message.worktreeManager;
|
||||
return;
|
||||
}
|
||||
if (message.type === "settings.changed") {
|
||||
this.dependencies.onSettingsChanged?.(loaded.id, message.settingsId);
|
||||
return;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,10 +1,25 @@
|
||||
import type { ForgeService, PullRequestCheckoutTarget } from "../services/forge-service.js";
|
||||
import type { WorktreeCheckoutRef, WorktreeSource } from "../utils/worktree.js";
|
||||
import type { UntrustedWorkspaceSource } from "./workspace-automation-gate.js";
|
||||
|
||||
export type WorktreeCreationIntent = Exclude<
|
||||
WorktreeSource,
|
||||
{ kind: "restore" | "restore-from-base" | "restore-commit" }
|
||||
>;
|
||||
> & { untrustedSource?: UntrustedWorkspaceSource };
|
||||
|
||||
export function worktreeUntrustedSource(
|
||||
intent: WorktreeCreationIntent,
|
||||
): UntrustedWorkspaceSource | undefined {
|
||||
if (intent.kind === "checkout-change-request" && intent.headRepository) {
|
||||
return {
|
||||
kind: "change_request",
|
||||
forge: intent.forge,
|
||||
number: intent.changeRequestNumber,
|
||||
headRepository: intent.headRepository,
|
||||
};
|
||||
}
|
||||
return intent.untrustedSource;
|
||||
}
|
||||
|
||||
export interface ResolveWorktreeCreationIntentInput {
|
||||
worktreeSlug?: string;
|
||||
@@ -156,7 +171,11 @@ async function fetchChangeRequestHead(params: {
|
||||
changeRequest: { number: number; forge?: string };
|
||||
repoRoot: string;
|
||||
deps: ResolveWorktreeCreationIntentDeps;
|
||||
}): Promise<{ baseBranch: string; startPoint: string }> {
|
||||
}): Promise<{
|
||||
baseBranch: string;
|
||||
startPoint: string;
|
||||
untrustedSource?: UntrustedWorkspaceSource;
|
||||
}> {
|
||||
const { input, changeRequest, repoRoot, deps } = params;
|
||||
assertCheckoutSourceMatchesResolvedForge(changeRequest, deps);
|
||||
const checkout = await resolvePrCheckoutIntent({
|
||||
@@ -165,6 +184,7 @@ async function fetchChangeRequestHead(params: {
|
||||
repoRoot,
|
||||
deps,
|
||||
});
|
||||
const untrustedSource = worktreeUntrustedSource(checkout);
|
||||
const startPoint = `refs/paseo/change-requests/${changeRequest.number}`;
|
||||
const remote = await deps.fetchRef({
|
||||
repoRoot,
|
||||
@@ -180,10 +200,10 @@ async function fetchChangeRequestHead(params: {
|
||||
sources: [{ remoteName: remote, remoteRef: `refs/heads/${baseName}` }],
|
||||
destination: baseBranch,
|
||||
});
|
||||
return { baseBranch, startPoint };
|
||||
return { baseBranch, startPoint, untrustedSource };
|
||||
} catch {
|
||||
// Without the remote's copy, the base resolves as any base branch name does.
|
||||
return { baseBranch: baseName, startPoint };
|
||||
return { baseBranch: baseName, startPoint, untrustedSource };
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -529,6 +529,10 @@ test("routes plugin requests and releases its owned catalog subscription on clea
|
||||
return request;
|
||||
},
|
||||
emit: () => {},
|
||||
hasWorktreeManager: () => false,
|
||||
createWorktree: async () => null,
|
||||
removeWorktree: async () => null,
|
||||
restoreWorktree: async () => null,
|
||||
listPlugins: async () => [plugin],
|
||||
getLogs: () => [
|
||||
{
|
||||
@@ -670,6 +674,10 @@ test("leaves out the client bundles a catalog request already holds", async () =
|
||||
const pluginRuntime: NonNullable<SessionOptions["pluginRuntime"]> = {
|
||||
before: async (_name, request) => request,
|
||||
emit: () => {},
|
||||
hasWorktreeManager: () => false,
|
||||
createWorktree: async () => null,
|
||||
removeWorktree: async () => null,
|
||||
restoreWorktree: async () => null,
|
||||
listPlugins: async () => [],
|
||||
getLogs: () => [],
|
||||
installDirectory: async () => {
|
||||
|
||||
@@ -113,6 +113,7 @@ import {
|
||||
assertWorkspaceAutomationAllowedForWorkspace,
|
||||
clearWorkspaceAutomationBlock,
|
||||
formatWorkspaceAutomationBlockedMessage,
|
||||
isCheckoutUntrusted,
|
||||
} from "./workspace-automation-gate.js";
|
||||
import {
|
||||
WorkspaceLabelError,
|
||||
@@ -246,7 +247,12 @@ import {
|
||||
matchesAgentUpdatesFilter,
|
||||
type AgentUpdatesService,
|
||||
} from "./session/agent-updates/agent-updates-service.js";
|
||||
import { expandTilde } from "../utils/path.js";
|
||||
import {
|
||||
createRealpathAwarePathMatcher,
|
||||
expandTilde,
|
||||
isRealpathInsideRoot,
|
||||
normalizePathForIdentity,
|
||||
} from "../utils/path.js";
|
||||
import {
|
||||
searchDirectoryEntries,
|
||||
WORKSPACE_SEARCH_HIDDEN_DIRECTORIES,
|
||||
@@ -287,7 +293,11 @@ import {
|
||||
handleWorkspaceSetupStatusRequest as handleWorkspaceSetupStatusRequestMessage,
|
||||
handleWorkspaceSetupRunRequest as handleWorkspaceSetupRunRequestMessage,
|
||||
} from "./worktree-session.js";
|
||||
import { archiveByScope, type ActiveWorkspaceRef } from "./workspace-archive-service.js";
|
||||
import {
|
||||
archiveByScope,
|
||||
resolveWorkspaceBackingPath,
|
||||
type ActiveWorkspaceRef,
|
||||
} from "./workspace-archive-service.js";
|
||||
import {
|
||||
WorkspaceArchiveOperations,
|
||||
type WorkspaceArchiveUndoInput,
|
||||
@@ -529,6 +539,10 @@ export interface SessionOptions {
|
||||
wait: import("./plugins/lifecycle/index.js").PluginLifecycle["wait"];
|
||||
before: import("./plugins/lifecycle/index.js").PluginLifecycle["before"];
|
||||
emit: import("./plugins/lifecycle/index.js").PluginLifecycle["emit"];
|
||||
hasWorktreeManager: import("./plugins/runtime.js").PluginWorktreeManagerRuntime["hasWorktreeManager"];
|
||||
createWorktree: import("./plugins/runtime.js").PluginWorktreeManagerRuntime["createWorktree"];
|
||||
removeWorktree: import("./plugins/runtime.js").PluginWorktreeManagerRuntime["removeWorktree"];
|
||||
restoreWorktree: import("./plugins/runtime.js").PluginWorktreeManagerRuntime["restoreWorktree"];
|
||||
listPlugins(): Promise<import("@getpaseo/protocol/messages").PluginListItem[]>;
|
||||
getLogs(pluginId: string): import("@getpaseo/protocol/messages").PluginLogEntry[];
|
||||
installDirectory(input: {
|
||||
@@ -1034,12 +1048,34 @@ export class Session {
|
||||
this.workspaceRecovery = createWorkspaceRecoveryService({
|
||||
paseoHome: this.paseoHome,
|
||||
worktreesRoot: this.worktreesRoot,
|
||||
worktreeManagers: this.pluginRuntime,
|
||||
getWorkspace: (workspaceId) => this.workspaceRegistry.get(workspaceId),
|
||||
getProject: (projectId) => this.projectRegistry.get(projectId),
|
||||
isDirectory: (path) => this.filesystem.isDirectory(path),
|
||||
unarchiveWorkspace: async (workspace) => {
|
||||
await this.workspaceProvisioning.ensureWorkspaceRecordUnarchived(workspace);
|
||||
},
|
||||
isCheckoutUntrusted: (checkoutPath) =>
|
||||
isCheckoutUntrusted(this.workspaceRegistry, checkoutPath),
|
||||
syncCheckoutWorktreeManager: async ({
|
||||
worktreeRoot,
|
||||
worktreeManagerPluginId,
|
||||
excludeWorkspaceId,
|
||||
}) => {
|
||||
const matchesCheckout = createRealpathAwarePathMatcher(worktreeRoot);
|
||||
const workspaces = await this.workspaceRegistry.listAll();
|
||||
const timestamp = new Date().toISOString();
|
||||
for (const candidate of workspaces) {
|
||||
if (candidate.workspaceId === excludeWorkspaceId) continue;
|
||||
if (!matchesCheckout(candidate.worktreeRoot ?? candidate.cwd)) continue;
|
||||
if ((candidate.worktreeManagerPluginId ?? null) === worktreeManagerPluginId) continue;
|
||||
const { worktreeManagerPluginId: _previous, ...withoutManager } = candidate;
|
||||
const updated: PersistedWorkspaceRecord = worktreeManagerPluginId
|
||||
? { ...withoutManager, worktreeManagerPluginId, updatedAt: timestamp }
|
||||
: { ...withoutManager, updatedAt: timestamp };
|
||||
await this.workspaceRegistry.upsert(updated);
|
||||
}
|
||||
},
|
||||
});
|
||||
this.diffSession = new DiffSession(checkoutDiffManager.streams, this.sessionLogger);
|
||||
this.checkoutSession = new CheckoutSession({
|
||||
@@ -1251,9 +1287,15 @@ export class Session {
|
||||
),
|
||||
logger: this.sessionLogger,
|
||||
});
|
||||
this.workspaceArchiveOperations = resolveWorkspaceArchiveOperations(workspaceArchiveOperations);
|
||||
this.createAgentLifecycleDispatch = new CreateAgentLifecycleDispatch({
|
||||
paseoHome: this.paseoHome,
|
||||
worktreesRoot: this.worktreesRoot,
|
||||
worktreeManagers: this.pluginRuntime,
|
||||
workspaceArchiveOperations: this.workspaceArchiveOperations,
|
||||
getWorkspace: (workspaceId) => this.workspaceRegistry.get(workspaceId),
|
||||
isCheckoutUntrusted: (checkoutPath) =>
|
||||
isCheckoutUntrusted(this.workspaceRegistry, checkoutPath),
|
||||
agentManager: this.agentManager,
|
||||
agentStorage: this.agentStorage,
|
||||
github: this.github,
|
||||
@@ -1292,7 +1334,6 @@ export class Session {
|
||||
},
|
||||
);
|
||||
this.workspaceSetupRuntime = resolveWorkspaceSetupRuntime(workspaceSetupRuntime);
|
||||
this.workspaceArchiveOperations = resolveWorkspaceArchiveOperations(workspaceArchiveOperations);
|
||||
this.getDaemonTcpPort = getDaemonTcpPort ?? null;
|
||||
this.getDaemonTcpHost = getDaemonTcpHost ?? null;
|
||||
this.serviceProxyPublicBaseUrl = serviceProxyPublicBaseUrl ?? null;
|
||||
@@ -5780,11 +5821,14 @@ export class Session {
|
||||
{
|
||||
paseoHome: this.paseoHome,
|
||||
paseoWorktreesBaseRoot: this.worktreesRoot,
|
||||
worktreeManagers: this.pluginRuntime,
|
||||
workspaceArchiveOperations: this.workspaceArchiveOperations,
|
||||
github: this.github,
|
||||
workspaceGitService: this.workspaceGitService,
|
||||
agentManager: this.agentManager,
|
||||
agentStorage: this.agentStorage,
|
||||
findWorkspaceIdForCwd: (cwd) => this.findWorkspaceIdForCwd(cwd),
|
||||
getWorkspace: (workspaceId) => this.workspaceRegistry.get(workspaceId),
|
||||
listActiveWorkspaces: () => this.listActiveWorkspaceRefs(),
|
||||
archiveWorkspaceRecord: (workspaceId, archivedAt) =>
|
||||
this.archiveWorkspaceRecord(workspaceId, archivedAt),
|
||||
@@ -5796,6 +5840,8 @@ export class Session {
|
||||
clearWorkspaceArchiving: (workspaceIds) => this.clearWorkspaceArchiving(workspaceIds),
|
||||
killTerminalsForWorkspace: (workspaceId) =>
|
||||
this.terminalController.killTerminalsForWorkspace(workspaceId),
|
||||
isCheckoutUntrusted: (checkoutPath) =>
|
||||
isCheckoutUntrusted(this.workspaceRegistry, checkoutPath),
|
||||
sessionLogger: this.sessionLogger,
|
||||
},
|
||||
msg,
|
||||
@@ -6501,9 +6547,60 @@ export class Session {
|
||||
};
|
||||
}
|
||||
|
||||
private async withWorkspaceCheckout<T>(workspaceId: string, run: () => Promise<T>): Promise<T> {
|
||||
const workspace = await this.workspaceRegistry.get(workspaceId);
|
||||
if (!workspace) {
|
||||
return run();
|
||||
}
|
||||
const checkoutPath = await resolveWorkspaceBackingPath(workspace, {
|
||||
paseoHome: this.paseoHome,
|
||||
paseoWorktreesBaseRoot: this.worktreesRoot,
|
||||
});
|
||||
return this.workspaceArchiveOperations.withCheckout(checkoutPath, run);
|
||||
}
|
||||
|
||||
private async withCheckoutForDirectory<T>(cwd: string, run: () => Promise<T>): Promise<T> {
|
||||
const normalizedCwd = resolve(cwd);
|
||||
const matchesCwd = createRealpathAwarePathMatcher(normalizedCwd);
|
||||
const workspaces = await this.workspaceRegistry.listAll();
|
||||
let matchingWorkspace = workspaces.find((workspace) => matchesCwd(workspace.cwd));
|
||||
if (!matchingWorkspace) {
|
||||
let bestDepth = -1;
|
||||
for (const workspace of workspaces) {
|
||||
if (
|
||||
workspace.worktreeRoot !== null &&
|
||||
isRealpathInsideRoot(workspace.worktreeRoot, normalizedCwd)
|
||||
) {
|
||||
const depth = normalizePathForIdentity(workspace.worktreeRoot).length;
|
||||
if (depth > bestDepth) {
|
||||
bestDepth = depth;
|
||||
matchingWorkspace = workspace;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
let checkoutPath = normalizedCwd;
|
||||
if (matchingWorkspace) {
|
||||
checkoutPath = await resolveWorkspaceBackingPath(matchingWorkspace, {
|
||||
paseoHome: this.paseoHome,
|
||||
paseoWorktreesBaseRoot: this.worktreesRoot,
|
||||
});
|
||||
} else {
|
||||
const checkout = await this.workspaceGitService.getCheckout(normalizedCwd);
|
||||
if (checkout.isGit && checkout.worktreeRoot) {
|
||||
checkoutPath = resolve(checkout.worktreeRoot);
|
||||
}
|
||||
}
|
||||
return this.workspaceArchiveOperations.withCheckout(checkoutPath, run);
|
||||
}
|
||||
|
||||
private async restoreWorkspaceAndEmit(workspaceId: string): Promise<void> {
|
||||
await this.workspaceRecovery.restore(workspaceId);
|
||||
await this.publishRecoveredWorkspace(workspaceId);
|
||||
await this.workspaceArchiveOperations.restore(workspaceId, () =>
|
||||
this.withWorkspaceCheckout(workspaceId, async () => {
|
||||
await this.workspaceRecovery.restore(workspaceId);
|
||||
await this.publishRecoveredWorkspace(workspaceId);
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
private async publishRecoveredWorkspace(workspaceId: string): Promise<void> {
|
||||
@@ -6550,6 +6647,7 @@ export class Session {
|
||||
): Promise<CreatePaseoWorktreeResult> {
|
||||
const result = await createPaseoWorktree(input, {
|
||||
lifecycle: this.pluginRuntime,
|
||||
worktreeManagers: this.pluginRuntime,
|
||||
github: this.github,
|
||||
...(options?.resolveDefaultBranch
|
||||
? { resolveDefaultBranch: options.resolveDefaultBranch }
|
||||
@@ -6580,6 +6678,8 @@ export class Session {
|
||||
worktreeRoot: workspace.worktreeRoot,
|
||||
isPaseoOwnedWorktree: workspace.isPaseoOwnedWorktree,
|
||||
mainRepoRoot: workspace.mainRepoRoot,
|
||||
worktreeManagerPluginId: workspace.worktreeManagerPluginId,
|
||||
untrustedSource: workspace.untrustedSource,
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -7434,24 +7534,29 @@ export class Session {
|
||||
}
|
||||
|
||||
const cwd = expandTilde(request.source.path);
|
||||
const directoryExists = await this.filesystem.isDirectory(cwd).catch(() => false);
|
||||
if (!directoryExists) {
|
||||
throw new SessionRequestError("directory_not_found", `Directory not found: ${cwd}`);
|
||||
}
|
||||
|
||||
const explicitTitle = request.title?.trim() || null;
|
||||
const promptTitle = resolveFirstAgentPromptTitle(request.firstAgentContext);
|
||||
const workspace = await this.workspaceProvisioning.createWorkspaceForDirectory(
|
||||
cwd,
|
||||
explicitTitle ?? promptTitle,
|
||||
request.source.projectId,
|
||||
{
|
||||
expectsInitialAgent: Boolean(request.firstAgentContext),
|
||||
workspaceId,
|
||||
metadata: request.metadata,
|
||||
...(await this.workspaceBackgroundIntent(request.background, request.callerAgentId)),
|
||||
},
|
||||
const backgroundIntent = await this.workspaceBackgroundIntent(
|
||||
request.background,
|
||||
request.callerAgentId,
|
||||
);
|
||||
const workspace = await this.withCheckoutForDirectory(cwd, async () => {
|
||||
const directoryExists = await this.filesystem.isDirectory(cwd).catch(() => false);
|
||||
if (!directoryExists) {
|
||||
throw new SessionRequestError("directory_not_found", `Directory not found: ${cwd}`);
|
||||
}
|
||||
return this.workspaceProvisioning.createWorkspaceForDirectory(
|
||||
cwd,
|
||||
explicitTitle ?? promptTitle,
|
||||
request.source.projectId,
|
||||
{
|
||||
expectsInitialAgent: Boolean(request.firstAgentContext),
|
||||
workspaceId,
|
||||
metadata: request.metadata,
|
||||
...backgroundIntent,
|
||||
},
|
||||
);
|
||||
});
|
||||
await this.syncWorkspaceGitObserverForWorkspace(workspace);
|
||||
const descriptor = await this.describeWorkspaceRecord(workspace);
|
||||
await this.emitCreatedWorkspaceUpdate(
|
||||
@@ -7533,34 +7638,41 @@ export class Session {
|
||||
): Promise<void> {
|
||||
const requestedCwd = request.cwd;
|
||||
const cwd = expandTilde(requestedCwd);
|
||||
const directoryExists = await this.filesystem.isDirectory(cwd).catch(() => false);
|
||||
if (!directoryExists) {
|
||||
this.sessionLogger.info(
|
||||
{ requestedCwd, resolvedCwd: cwd, reason: "directory_not_found" },
|
||||
"Open project rejected",
|
||||
);
|
||||
this.emit({
|
||||
type: "open_project_response",
|
||||
payload: {
|
||||
requestId: request.requestId,
|
||||
workspace: null,
|
||||
error: `Directory not found: ${cwd}`,
|
||||
errorCode: "directory_not_found",
|
||||
},
|
||||
});
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
const projectsBefore = new Map<string, PersistedProjectRecord>();
|
||||
for (const project of await this.projectRegistry.list()) {
|
||||
projectsBefore.set(project.projectId, project);
|
||||
const opened = await this.withCheckoutForDirectory(cwd, async () => {
|
||||
const directoryExists = await this.filesystem.isDirectory(cwd).catch(() => false);
|
||||
if (!directoryExists) {
|
||||
return null;
|
||||
}
|
||||
const projectsBefore = new Map<string, PersistedProjectRecord>();
|
||||
for (const project of await this.projectRegistry.list()) {
|
||||
projectsBefore.set(project.projectId, project);
|
||||
}
|
||||
const workspacesBefore = new Map<string, PersistedWorkspaceRecord>();
|
||||
for (const workspaceRecord of await this.workspaceRegistry.listActive()) {
|
||||
workspacesBefore.set(workspaceRecord.workspaceId, workspaceRecord);
|
||||
}
|
||||
const workspace = await this.workspaceProvisioning.findOrCreateWorkspaceForDirectory(cwd);
|
||||
return { workspace, projectsBefore, workspacesBefore };
|
||||
});
|
||||
if (!opened) {
|
||||
this.sessionLogger.info(
|
||||
{ requestedCwd, resolvedCwd: cwd, reason: "directory_not_found" },
|
||||
"Open project rejected",
|
||||
);
|
||||
this.emit({
|
||||
type: "open_project_response",
|
||||
payload: {
|
||||
requestId: request.requestId,
|
||||
workspace: null,
|
||||
error: `Directory not found: ${cwd}`,
|
||||
errorCode: "directory_not_found",
|
||||
},
|
||||
});
|
||||
return;
|
||||
}
|
||||
const workspacesBefore = new Map<string, PersistedWorkspaceRecord>();
|
||||
for (const workspaceRecord of await this.workspaceRegistry.listActive()) {
|
||||
workspacesBefore.set(workspaceRecord.workspaceId, workspaceRecord);
|
||||
}
|
||||
const workspace = await this.workspaceProvisioning.findOrCreateWorkspaceForDirectory(cwd);
|
||||
const { workspace, projectsBefore, workspacesBefore } = opened;
|
||||
const project = await this.projectRegistry.get(workspace.projectId);
|
||||
await this.syncWorkspaceGitObserverForWorkspace(workspace);
|
||||
const descriptor = await this.describeWorkspaceRecord(workspace);
|
||||
@@ -8128,6 +8240,8 @@ export class Session {
|
||||
{
|
||||
paseoHome: this.paseoHome,
|
||||
paseoWorktreesBaseRoot: this.worktreesRoot,
|
||||
worktreeManagers: this.pluginRuntime,
|
||||
workspaceArchiveOperations: this.workspaceArchiveOperations,
|
||||
github: this.github,
|
||||
workspaceGitService: this.workspaceGitService,
|
||||
agentManager: this.agentManager,
|
||||
@@ -8144,6 +8258,8 @@ export class Session {
|
||||
clearWorkspaceArchiving: (workspaceIds) => this.clearWorkspaceArchiving(workspaceIds),
|
||||
assertWorkspaceAutomationAllowed: (workspaceId) =>
|
||||
assertWorkspaceAutomationAllowedForWorkspace(this.workspaceRegistry, workspaceId),
|
||||
isCheckoutUntrusted: (checkoutPath) =>
|
||||
isCheckoutUntrusted(this.workspaceRegistry, checkoutPath),
|
||||
killTerminalsForWorkspace: (workspaceId) =>
|
||||
this.terminalController.killTerminalsForWorkspace(workspaceId),
|
||||
stopWorkspaceSetup: (workspaceId) => this.workspaceSetupRuntime.stop(workspaceId),
|
||||
@@ -8206,7 +8322,9 @@ export class Session {
|
||||
): Promise<void> {
|
||||
try {
|
||||
await this.workspaceArchiveOperations.undo(request.workspaceId, (input) =>
|
||||
this.restoreArchivedWorkspaceAndAgents(request.workspaceId, input),
|
||||
this.withWorkspaceCheckout(request.workspaceId, () =>
|
||||
this.restoreArchivedWorkspaceAndAgents(request.workspaceId, input),
|
||||
),
|
||||
);
|
||||
this.emit({
|
||||
type: "workspace.archive.undo.response",
|
||||
|
||||
+11
@@ -52,6 +52,7 @@ export interface CreateWorktreeWorkspaceInput {
|
||||
worktreeRoot: string;
|
||||
branch: string | null;
|
||||
baseBranch: string | null;
|
||||
worktreeManagerPluginId?: string | null;
|
||||
title: string | null;
|
||||
metadata?: Record<string, JsonValue>;
|
||||
expectsInitialAgent?: boolean;
|
||||
@@ -273,14 +274,23 @@ export function createWorkspaceProvisioningService(deps: {
|
||||
checkout.isGit && checkout.isPaseoOwnedWorktree
|
||||
? await readPaseoWorktreeMetadata(checkout.worktreeRoot ?? normalizedCwd)
|
||||
: null;
|
||||
const checkoutRoot = checkout.worktreeRoot ?? normalizedCwd;
|
||||
const matchesCheckout = createRealpathAwarePathMatcher(checkoutRoot);
|
||||
const inheritedUntrustedSource = (await workspaceRegistry.listAll()).find(
|
||||
(candidate) =>
|
||||
Boolean(candidate.untrustedSource) &&
|
||||
matchesCheckout(candidate.worktreeRoot ?? candidate.cwd),
|
||||
)?.untrustedSource;
|
||||
const timestamp = new Date().toISOString();
|
||||
const workspace = createPersistedWorkspaceRecord({
|
||||
workspaceId: context?.workspaceId ?? generateWorkspaceId(),
|
||||
projectId: project.projectId,
|
||||
...initialWorkspacePlacement({ source: "checkout", cwd: normalizedCwd, checkout }),
|
||||
baseBranch: baseMetadata?.baseRef ?? baseMetadata?.baseRefName ?? null,
|
||||
worktreeManagerPluginId: baseMetadata?.worktreeManagerPluginId ?? null,
|
||||
title: title?.trim() || null,
|
||||
metadata: context?.metadata,
|
||||
...(inheritedUntrustedSource ? { untrustedSource: inheritedUntrustedSource } : {}),
|
||||
createdAt: timestamp,
|
||||
updatedAt: timestamp,
|
||||
...(await resolveCreationMetadata(context)),
|
||||
@@ -320,6 +330,7 @@ export function createWorkspaceProvisioningService(deps: {
|
||||
baseBranch: input.baseBranch,
|
||||
mainRepoRoot: repoRoot,
|
||||
}),
|
||||
worktreeManagerPluginId: input.worktreeManagerPluginId ?? null,
|
||||
title: input.title,
|
||||
metadata: input.metadata,
|
||||
createdAt: timestamp,
|
||||
|
||||
+126
-11
@@ -9,8 +9,11 @@ import {
|
||||
isPaseoOwnedWorktreeCwd,
|
||||
mapWorkspaceCwdToWorktree,
|
||||
rollbackCreatedPaseoWorktree,
|
||||
runPluginWorktreeManagerCheckout,
|
||||
type WorktreeSource,
|
||||
} from "../../../utils/worktree.js";
|
||||
import type { PluginWorktreeManagerRuntime } from "../../plugins/runtime.js";
|
||||
import type { PluginWorktreeRestoreTarget } from "@getpaseo/plugin/server";
|
||||
import { WorktreeRequestError, toWorktreeRequestError } from "../../worktree-errors.js";
|
||||
import {
|
||||
resolveWorkspaceDisplayName,
|
||||
@@ -64,10 +67,20 @@ type UnavailableRecoveryState = Extract<WorkspaceRecoveryState, { kind: "unavail
|
||||
export function createWorkspaceRecoveryService(deps: {
|
||||
paseoHome: string;
|
||||
worktreesRoot?: string;
|
||||
worktreeManagers?: Pick<
|
||||
PluginWorktreeManagerRuntime,
|
||||
"hasWorktreeManager" | "restoreWorktree" | "removeWorktree"
|
||||
>;
|
||||
getWorkspace: (workspaceId: string) => Promise<PersistedWorkspaceRecord | null>;
|
||||
getProject: (projectId: string) => Promise<PersistedProjectRecord | null>;
|
||||
isDirectory: (path: string) => Promise<boolean>;
|
||||
unarchiveWorkspace: (workspace: PersistedWorkspaceRecord) => Promise<void>;
|
||||
isCheckoutUntrusted?: (checkoutPath: string) => Promise<boolean>;
|
||||
syncCheckoutWorktreeManager?: (input: {
|
||||
worktreeRoot: string;
|
||||
worktreeManagerPluginId: string | null;
|
||||
excludeWorkspaceId: string;
|
||||
}) => Promise<void>;
|
||||
}): WorkspaceRecoveryService {
|
||||
async function resolveRecovery(
|
||||
workspaceId: string,
|
||||
@@ -140,17 +153,32 @@ export function createWorkspaceRecoveryService(deps: {
|
||||
throw new Error(resolved.message);
|
||||
}
|
||||
|
||||
let workspaceToUnarchive = resolved.workspace;
|
||||
let recreated: { worktreePath: string; pluginId: string | null } | null = null;
|
||||
if (resolved.kind === "restore") {
|
||||
await recreateArchivedWorktree(resolved.workspace, resolved.sourceRepoRoot);
|
||||
recreated = await recreateArchivedWorktree(resolved.workspace, resolved.sourceRepoRoot);
|
||||
if ((resolved.workspace.worktreeManagerPluginId ?? null) !== recreated.pluginId) {
|
||||
const { worktreeManagerPluginId: _previous, ...withoutManager } = resolved.workspace;
|
||||
workspaceToUnarchive = recreated.pluginId
|
||||
? { ...withoutManager, worktreeManagerPluginId: recreated.pluginId }
|
||||
: withoutManager;
|
||||
}
|
||||
}
|
||||
await deps.unarchiveWorkspace(workspaceToUnarchive);
|
||||
if (recreated) {
|
||||
await deps.syncCheckoutWorktreeManager?.({
|
||||
worktreeRoot: recreated.worktreePath,
|
||||
worktreeManagerPluginId: recreated.pluginId,
|
||||
excludeWorkspaceId: workspaceId,
|
||||
});
|
||||
}
|
||||
await deps.unarchiveWorkspace(resolved.workspace);
|
||||
return { workspaceId, action: resolved.kind };
|
||||
}
|
||||
|
||||
async function recreateArchivedWorktree(
|
||||
workspace: PersistedWorkspaceRecord,
|
||||
sourceRepoRoot: string,
|
||||
): Promise<void> {
|
||||
): Promise<{ worktreePath: string; pluginId: string | null }> {
|
||||
let source: WorktreeSource;
|
||||
const checkout = parseWorkspaceHead(workspace);
|
||||
if (checkout.kind === "branch") {
|
||||
@@ -194,18 +222,22 @@ export function createWorkspaceRecoveryService(deps: {
|
||||
hasRecordedWorktreePath = ownership.allowed;
|
||||
}
|
||||
|
||||
const untrusted =
|
||||
Boolean(workspace.untrustedSource) ||
|
||||
Boolean(await deps.isCheckoutUntrusted?.(previousWorktreePath));
|
||||
let recreatedWorktreePath: string;
|
||||
let restoredByPluginId: string | null = null;
|
||||
try {
|
||||
const result = await createWorktree({
|
||||
cwd: sourceRepoRoot,
|
||||
worktreeSlug: basename(previousWorktreePath),
|
||||
const restored = await recreateWorktreeCheckout({
|
||||
workspace,
|
||||
sourceRepoRoot,
|
||||
source,
|
||||
|
||||
paseoHome: deps.paseoHome,
|
||||
worktreesRoot: deps.worktreesRoot,
|
||||
...(hasRecordedWorktreePath ? { worktreePath: previousWorktreePath } : {}),
|
||||
previousWorktreePath,
|
||||
hasRecordedWorktreePath,
|
||||
untrusted,
|
||||
});
|
||||
recreatedWorktreePath = result.worktreePath;
|
||||
recreatedWorktreePath = restored.worktreePath;
|
||||
restoredByPluginId = restored.pluginId;
|
||||
} catch (error) {
|
||||
throw toWorktreeRequestError(error);
|
||||
}
|
||||
@@ -236,15 +268,98 @@ export function createWorkspaceRecoveryService(deps: {
|
||||
teardownCwds: [],
|
||||
paseoHome: deps.paseoHome,
|
||||
worktreesBaseRoot: deps.worktreesRoot,
|
||||
worktreeManagers: deps.worktreeManagers,
|
||||
worktreeManagerPluginId: restoredByPluginId,
|
||||
removeReason: "rollback",
|
||||
untrusted,
|
||||
},
|
||||
error,
|
||||
);
|
||||
}
|
||||
return { worktreePath: recreatedWorktreePath, pluginId: restoredByPluginId };
|
||||
}
|
||||
|
||||
async function recreateWorktreeCheckout(options: {
|
||||
workspace: PersistedWorkspaceRecord;
|
||||
sourceRepoRoot: string;
|
||||
source: Extract<WorktreeSource, { kind: "restore" | "restore-commit" | "restore-from-base" }>;
|
||||
previousWorktreePath: string;
|
||||
hasRecordedWorktreePath: boolean;
|
||||
untrusted: boolean;
|
||||
}): Promise<{ worktreePath: string; pluginId: string | null }> {
|
||||
const {
|
||||
workspace,
|
||||
sourceRepoRoot,
|
||||
source,
|
||||
previousWorktreePath,
|
||||
hasRecordedWorktreePath,
|
||||
untrusted,
|
||||
} = options;
|
||||
const managerPluginId = workspace.worktreeManagerPluginId;
|
||||
if (managerPluginId && hasRecordedWorktreePath && deps.worktreeManagers) {
|
||||
const adopted = await runPluginWorktreeManagerCheckout({
|
||||
cwd: sourceRepoRoot,
|
||||
source,
|
||||
operation: "restore",
|
||||
preferredPluginId: managerPluginId,
|
||||
untrusted,
|
||||
paseoHome: deps.paseoHome,
|
||||
worktreesBaseRoot: deps.worktreesRoot,
|
||||
worktreeManagers: deps.worktreeManagers,
|
||||
run: () =>
|
||||
deps.worktreeManagers!.restoreWorktree(
|
||||
{
|
||||
repoRoot: sourceRepoRoot,
|
||||
path: previousWorktreePath,
|
||||
target: restoreTargetFromWorktreeSource(source),
|
||||
baseRef: workspace.baseBranch,
|
||||
untrusted,
|
||||
},
|
||||
{ preferredPluginId: managerPluginId },
|
||||
),
|
||||
verifyValidatedPath: (validatedPath, pluginId) => {
|
||||
if (!createRealpathAwarePathMatcher(previousWorktreePath)(validatedPath)) {
|
||||
throw new WorktreeRequestError({
|
||||
code: "unknown",
|
||||
message: `Plugin ${pluginId} restored worktree to ${validatedPath}, expected ${previousWorktreePath}`,
|
||||
});
|
||||
}
|
||||
},
|
||||
});
|
||||
if (adopted) {
|
||||
return {
|
||||
worktreePath: adopted.worktreePath,
|
||||
pluginId: adopted.worktreeManagerPluginId ?? managerPluginId,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
const result = await createWorktree({
|
||||
cwd: sourceRepoRoot,
|
||||
worktreeSlug: basename(previousWorktreePath),
|
||||
source,
|
||||
paseoHome: deps.paseoHome,
|
||||
worktreesRoot: deps.worktreesRoot,
|
||||
...(hasRecordedWorktreePath ? { worktreePath: previousWorktreePath } : {}),
|
||||
});
|
||||
return { worktreePath: result.worktreePath, pluginId: null };
|
||||
}
|
||||
|
||||
return { inspect, restore };
|
||||
}
|
||||
|
||||
function restoreTargetFromWorktreeSource(
|
||||
source: Extract<WorktreeSource, { kind: "restore" | "restore-commit" | "restore-from-base" }>,
|
||||
): PluginWorktreeRestoreTarget {
|
||||
if (source.kind === "restore") {
|
||||
return { type: "branch", branch: source.branchName };
|
||||
}
|
||||
if (source.kind === "restore-commit") {
|
||||
return { type: "commit", commit: source.commit };
|
||||
}
|
||||
return { type: "from-base", branch: source.branchName, baseRef: source.baseRef };
|
||||
}
|
||||
|
||||
async function resolveRecoveryBase(repoRoot: string, recordedBase: string | null): Promise<string> {
|
||||
if (recordedBase) {
|
||||
try {
|
||||
|
||||
@@ -70,6 +70,12 @@ import type { HubRelationshipManagement } from "./hub/relationship-controller.js
|
||||
import { WorkspaceSetupObservation } from "./workspace-setup-observation.js";
|
||||
import { WorkspaceSetupRuntime } from "./workspace-setup-runtime.js";
|
||||
import { WorkspaceArchiveOperations } from "./workspace-archive-operations.js";
|
||||
|
||||
function resolveWorkspaceArchiveOperations(
|
||||
operations: WorkspaceArchiveOperations | undefined,
|
||||
): WorkspaceArchiveOperations {
|
||||
return operations ?? new WorkspaceArchiveOperations();
|
||||
}
|
||||
import type { HubExecutionAgents } from "./hub/daemon-executions.js";
|
||||
import type { AgentProvider } from "./agent/agent-sdk-types.js";
|
||||
import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
|
||||
@@ -618,9 +624,9 @@ export class VoiceAssistantWebSocketServer {
|
||||
private readonly voiceCallerContexts = new Map<string, VoiceCallerContext>();
|
||||
private readonly workspaceSetupObservation = new WorkspaceSetupObservation();
|
||||
private readonly workspaceSetupRuntime: WorkspaceSetupRuntime;
|
||||
// One lane per workspace across every connection, so an undo from any client can cancel an
|
||||
// archive another connection started.
|
||||
private readonly workspaceArchiveOperations = new WorkspaceArchiveOperations();
|
||||
// One lane per workspace and per checkout across the daemon, so archive, undo, and restore
|
||||
// from any client or background caller coordinate through one boundary.
|
||||
private readonly workspaceArchiveOperations: WorkspaceArchiveOperations;
|
||||
private readonly providerSnapshotManager: ProviderSnapshotManager;
|
||||
private onLifecycleIntent!: ((intent: SessionLifecycleIntent) => void) | null;
|
||||
private onBranchChanged!:
|
||||
@@ -711,9 +717,11 @@ export class VoiceAssistantWebSocketServer {
|
||||
pluginRuntime?: SessionOptions["pluginRuntime"],
|
||||
orchestrationSkills?: SessionOptions["orchestrationSkills"],
|
||||
workspaceLabelService?: WorkspaceLabelService,
|
||||
workspaceArchiveOperations?: WorkspaceArchiveOperations,
|
||||
) {
|
||||
this.logger = logger.child({ module: "websocket-server" });
|
||||
this.workspaceSetupRuntime = workspaceSetupRuntime;
|
||||
this.workspaceArchiveOperations = resolveWorkspaceArchiveOperations(workspaceArchiveOperations);
|
||||
this.advertiseDaemonStatusRpc = wsConfig.daemonStatusRpc !== false;
|
||||
this.advertiseRelayConfig = wsConfig.relayConfig !== false;
|
||||
this.connectionLifecycle = wsConfig.startPaused === true ? "starting" : "accepting";
|
||||
|
||||
@@ -273,4 +273,146 @@ describe("WorkspaceArchiveOperations", () => {
|
||||
kind: "archived",
|
||||
});
|
||||
});
|
||||
|
||||
test("concurrent restores join the in-flight restore and share its outcome", async () => {
|
||||
const operations = new WorkspaceArchiveOperations();
|
||||
let release!: () => void;
|
||||
const gate = new Promise<void>((resolve) => {
|
||||
release = resolve;
|
||||
});
|
||||
let calls = 0;
|
||||
|
||||
const first = operations.restore("ws", async () => {
|
||||
calls += 1;
|
||||
await gate;
|
||||
throw new Error("restore setup failed");
|
||||
});
|
||||
const second = operations.restore("ws", async () => {
|
||||
calls += 1;
|
||||
});
|
||||
|
||||
release();
|
||||
await expect(first).rejects.toThrow("restore setup failed");
|
||||
await expect(second).rejects.toThrow("restore setup failed");
|
||||
expect(calls).toBe(1);
|
||||
|
||||
await operations.restore("ws", async () => {
|
||||
calls += 1;
|
||||
});
|
||||
expect(calls).toBe(2);
|
||||
});
|
||||
|
||||
test("undo after a restore queued behind a running archive still aborts the archive and shares the undo outcome", async () => {
|
||||
const operations = new WorkspaceArchiveOperations();
|
||||
const archive = parkedArchive(["agent-a"]);
|
||||
const order: string[] = [];
|
||||
let restoreCalls = 0;
|
||||
|
||||
const archiveDone = operations.archive("ws", async (signal) => {
|
||||
try {
|
||||
return await archive.run(signal);
|
||||
} finally {
|
||||
order.push("archive stopped");
|
||||
}
|
||||
});
|
||||
await archive.started;
|
||||
|
||||
const restoreDone = operations.restore("ws", async () => {
|
||||
restoreCalls += 1;
|
||||
order.push("restore");
|
||||
});
|
||||
expect(archive.aborted).toBe(false);
|
||||
|
||||
const undoDone = operations.undo("ws", async ({ archivedAt }) => {
|
||||
order.push(`undo:${archivedAt}`);
|
||||
});
|
||||
expect(archive.aborted).toBe(true);
|
||||
|
||||
archive.release();
|
||||
await expect(archiveDone).resolves.toEqual({ kind: "canceled", archivedAt: "stamp" });
|
||||
await Promise.all([restoreDone, undoDone]);
|
||||
|
||||
expect(restoreCalls).toBe(0);
|
||||
expect(order).toEqual(["archive stopped", "undo:stamp"]);
|
||||
});
|
||||
|
||||
test("restore queued behind a running archive waits without aborting it when no undo arrives", async () => {
|
||||
const operations = new WorkspaceArchiveOperations();
|
||||
const archive = parkedArchive(["agent-a"]);
|
||||
const order: string[] = [];
|
||||
|
||||
const archiveDone = operations.archive("ws", async (signal) => {
|
||||
const result = await archive.run(signal);
|
||||
order.push("archived");
|
||||
return result;
|
||||
});
|
||||
await archive.started;
|
||||
|
||||
const restoreDone = operations.restore("ws", async () => {
|
||||
order.push("restored");
|
||||
});
|
||||
expect(archive.aborted).toBe(false);
|
||||
|
||||
archive.release();
|
||||
await expect(archiveDone).resolves.toMatchObject({ kind: "archived" });
|
||||
await restoreDone;
|
||||
expect(order).toEqual(["archived", "restored"]);
|
||||
});
|
||||
|
||||
test("undo after restore has already started joins the running restore", async () => {
|
||||
const operations = new WorkspaceArchiveOperations();
|
||||
await operations.archive("ws", async () => archived(["agent-a"]));
|
||||
|
||||
const restoreGate = deferred();
|
||||
let restoreCalls = 0;
|
||||
let undoCalls = 0;
|
||||
const restoreDone = operations.restore("ws", async () => {
|
||||
restoreCalls += 1;
|
||||
await restoreGate.promise;
|
||||
});
|
||||
// Flush microtask so restore has moved past any settled archive check.
|
||||
await Promise.resolve();
|
||||
|
||||
const undoDone = operations.undo("ws", async () => {
|
||||
undoCalls += 1;
|
||||
});
|
||||
restoreGate.resolve();
|
||||
await Promise.all([restoreDone, undoDone]);
|
||||
|
||||
expect(restoreCalls).toBe(1);
|
||||
expect(undoCalls).toBe(0);
|
||||
});
|
||||
|
||||
test("withCheckout serializes operations on the same checkout path while allowing independent checkouts in parallel", async () => {
|
||||
const operations = new WorkspaceArchiveOperations();
|
||||
const firstGate = deferred();
|
||||
const firstStarted = deferred();
|
||||
const order: string[] = [];
|
||||
|
||||
const first = operations.withCheckout("/tmp/paseo-checkout-a", async () => {
|
||||
order.push("a1-start");
|
||||
firstStarted.resolve();
|
||||
await firstGate.promise;
|
||||
order.push("a1-end");
|
||||
return "first";
|
||||
});
|
||||
await firstStarted.promise;
|
||||
|
||||
const second = operations.withCheckout("/tmp/paseo-checkout-a/", async () => {
|
||||
order.push("a2");
|
||||
return "second";
|
||||
});
|
||||
const other = operations.withCheckout("/tmp/paseo-checkout-b", async () => {
|
||||
order.push("b");
|
||||
return "other";
|
||||
});
|
||||
|
||||
await expect(other).resolves.toBe("other");
|
||||
expect(order).toEqual(["a1-start", "b"]);
|
||||
|
||||
firstGate.resolve();
|
||||
await expect(first).resolves.toBe("first");
|
||||
await expect(second).resolves.toBe("second");
|
||||
expect(order).toEqual(["a1-start", "b", "a1-end", "a2"]);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -1,3 +1,6 @@
|
||||
import { resolve } from "node:path";
|
||||
|
||||
import { normalizePathForIdentity } from "../utils/path.js";
|
||||
import { type ArchiveResult, WorkspaceArchiveCanceledError } from "./workspace-archive-service.js";
|
||||
|
||||
export type WorkspaceArchiveOutcome =
|
||||
@@ -8,23 +11,42 @@ export interface WorkspaceArchiveUndoInput {
|
||||
archivedAt?: string;
|
||||
}
|
||||
|
||||
interface PendingArchive {
|
||||
controller: AbortController;
|
||||
done: Promise<WorkspaceArchiveOutcome>;
|
||||
}
|
||||
|
||||
type LaneEntry =
|
||||
| { kind: "archiving"; controller: AbortController; done: Promise<WorkspaceArchiveOutcome> }
|
||||
| {
|
||||
kind: "restoring";
|
||||
pendingArchive: PendingArchive | null;
|
||||
supersededBy: Promise<void> | null;
|
||||
done: Promise<void>;
|
||||
}
|
||||
| { kind: "undoing"; done: Promise<void> };
|
||||
|
||||
/**
|
||||
* One lane per workspace for archive and its undo, shared by every session on the daemon.
|
||||
* Daemon-wide coordinator for workspace archive, undo, and restore operations.
|
||||
*
|
||||
* Per-workspace lanes:
|
||||
* - An archive while one runs joins it.
|
||||
* - An undo while an archive runs aborts it, waits for it to stop, then restores.
|
||||
* - An archive while an undo runs waits for the undo, then archives.
|
||||
* - An undo while an undo runs joins it.
|
||||
* - An undo while an archive runs (including when a restore queued behind it) aborts the archive,
|
||||
* waits for it to stop, then restores.
|
||||
* - A restore while an archive runs waits for the archive without aborting it, then restores.
|
||||
* - An archive while an undo or restore runs waits for it, then archives.
|
||||
* - A duplicate undo or restore while recovery runs joins it.
|
||||
*
|
||||
* Each call claims the lane synchronously, so whichever request arrives last decides the
|
||||
* workspace's final state no matter how the earlier work interleaves.
|
||||
* Per-checkout gates:
|
||||
* - Any archive or recovery mutating the same backing checkout directory (including CLI worktree
|
||||
* archives covering multiple workspace records, background auto-archives, and sibling workspaces
|
||||
* sharing one checkout) serializes through `withCheckout` so a restore cannot inspect or unarchive
|
||||
* a checkout while an archive is still deleting it.
|
||||
* - Lock order is strictly workspace lane -> checkout gate, preventing deadlocks.
|
||||
*/
|
||||
export class WorkspaceArchiveOperations {
|
||||
private readonly lanes = new Map<string, LaneEntry>();
|
||||
private readonly checkoutGates = new Map<string, Promise<void>>();
|
||||
|
||||
archive(
|
||||
workspaceId: string,
|
||||
@@ -57,16 +79,92 @@ export class WorkspaceArchiveOperations {
|
||||
if (current?.kind === "undoing") {
|
||||
return current.done;
|
||||
}
|
||||
current?.controller.abort();
|
||||
if (current?.kind === "restoring" && current.pendingArchive === null) {
|
||||
return current.done;
|
||||
}
|
||||
let pendingArchive: PendingArchive | null = null;
|
||||
if (current?.kind === "archiving") {
|
||||
pendingArchive = { controller: current.controller, done: current.done };
|
||||
} else if (current?.kind === "restoring") {
|
||||
pendingArchive = current.pendingArchive;
|
||||
}
|
||||
pendingArchive?.controller.abort();
|
||||
const done = (async () => {
|
||||
const outcome =
|
||||
current?.kind === "archiving" ? await current.done.catch(() => undefined) : undefined;
|
||||
const outcome = pendingArchive ? await pendingArchive.done.catch(() => undefined) : undefined;
|
||||
await restore({ archivedAt: outcome?.kind === "canceled" ? outcome.archivedAt : undefined });
|
||||
})();
|
||||
if (current?.kind === "restoring") {
|
||||
current.supersededBy = done;
|
||||
}
|
||||
this.claim(workspaceId, { kind: "undoing", done });
|
||||
return done;
|
||||
}
|
||||
|
||||
/**
|
||||
* Run a workspace recovery restore on the per-workspace lane so concurrent restores
|
||||
* across daemon sessions share one outcome and wait for checkout + validation to settle.
|
||||
* When queued behind an in-flight archive, the archive stays cancelable by a subsequent undo.
|
||||
*/
|
||||
restore(workspaceId: string, run: () => Promise<void>): Promise<void> {
|
||||
const current = this.lanes.get(workspaceId);
|
||||
if (current?.kind === "undoing" || current?.kind === "restoring") {
|
||||
return current.done;
|
||||
}
|
||||
const pendingArchive: PendingArchive | null =
|
||||
current?.kind === "archiving" ? { controller: current.controller, done: current.done } : null;
|
||||
const entry: Extract<LaneEntry, { kind: "restoring" }> = {
|
||||
kind: "restoring",
|
||||
pendingArchive,
|
||||
supersededBy: null,
|
||||
done: Promise.resolve(),
|
||||
};
|
||||
entry.done = (async () => {
|
||||
if (pendingArchive) {
|
||||
await settled(pendingArchive.done);
|
||||
entry.pendingArchive = null;
|
||||
if (entry.supersededBy) {
|
||||
await entry.supersededBy;
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
await settled(current?.done);
|
||||
}
|
||||
await run();
|
||||
})();
|
||||
this.claim(workspaceId, entry);
|
||||
return entry.done;
|
||||
}
|
||||
|
||||
/**
|
||||
* Serialize mutations touching the same backing checkout directory across all daemon callers
|
||||
* (UI archive, CLI worktree archive, background auto-archive, undo, and recovery restore).
|
||||
*/
|
||||
withCheckout<T>(checkoutPath: string, run: () => Promise<T>): Promise<T> {
|
||||
const key = normalizePathForIdentity(resolve(checkoutPath));
|
||||
const previous = this.checkoutGates.get(key);
|
||||
let release!: () => void;
|
||||
const current = new Promise<void>((resolveGate) => {
|
||||
release = resolveGate;
|
||||
});
|
||||
const gate = previous ? previous.then(() => current) : current;
|
||||
this.checkoutGates.set(key, gate);
|
||||
const cleanup = () => {
|
||||
if (this.checkoutGates.get(key) === gate) {
|
||||
this.checkoutGates.delete(key);
|
||||
}
|
||||
};
|
||||
void gate.then(cleanup, cleanup);
|
||||
|
||||
return (async () => {
|
||||
await settled(previous);
|
||||
try {
|
||||
return await run();
|
||||
} finally {
|
||||
release();
|
||||
}
|
||||
})();
|
||||
}
|
||||
|
||||
private claim(workspaceId: string, entry: LaneEntry): void {
|
||||
this.lanes.set(workspaceId, entry);
|
||||
const release = () => {
|
||||
|
||||
@@ -1290,3 +1290,54 @@ test("a canceled archive with no matching agents leaves earlier closed agents ar
|
||||
});
|
||||
expect(restored).toEqual([]);
|
||||
});
|
||||
|
||||
test("archiving an outer worktree preserves an active nested checkout and its uncommitted files", async () => {
|
||||
const { repoDir } = createGitRepo();
|
||||
const rootDir = path.dirname(repoDir);
|
||||
const outerPath = path.join(rootDir, "worktrees", "team");
|
||||
const innerPath = path.join(outerPath, "topic");
|
||||
mkdirSync(path.dirname(outerPath), { recursive: true });
|
||||
execFileSync("git", ["worktree", "add", "-b", "team", outerPath], {
|
||||
cwd: repoDir,
|
||||
stdio: "pipe",
|
||||
});
|
||||
execFileSync("git", ["worktree", "add", "-b", "topic", innerPath], {
|
||||
cwd: repoDir,
|
||||
stdio: "pipe",
|
||||
});
|
||||
const dirtyFile = path.join(innerPath, "uncommitted.txt");
|
||||
writeFileSync(dirtyFile, "keep-inner");
|
||||
|
||||
const activeWorkspaces: ActiveWorkspaceRef[] = [
|
||||
{
|
||||
workspaceId: "ws-team",
|
||||
cwd: outerPath,
|
||||
kind: "worktree",
|
||||
worktreeRoot: outerPath,
|
||||
isPaseoOwnedWorktree: true,
|
||||
mainRepoRoot: repoDir,
|
||||
},
|
||||
{
|
||||
workspaceId: "ws-topic",
|
||||
cwd: innerPath,
|
||||
kind: "worktree",
|
||||
worktreeRoot: innerPath,
|
||||
isPaseoOwnedWorktree: true,
|
||||
mainRepoRoot: repoDir,
|
||||
},
|
||||
];
|
||||
const deps = createArchiveDeps({
|
||||
paseoHome: rootDir,
|
||||
activeWorkspaces,
|
||||
});
|
||||
|
||||
const result = await archiveByScope(deps, {
|
||||
scope: { kind: "workspace", workspaceId: "ws-team" },
|
||||
requestId: "archive-outer",
|
||||
});
|
||||
|
||||
expect(result.archivedWorkspaceIds).toEqual(["ws-team"]);
|
||||
expect(result.removedDirectory).toBe(false);
|
||||
expect(existsSync(outerPath)).toBe(true);
|
||||
expect(readFileSync(dirtyFile, "utf8")).toBe("keep-inner");
|
||||
});
|
||||
|
||||
@@ -19,19 +19,26 @@ import type {
|
||||
WorkspaceArchiveContext,
|
||||
WorkspaceRegistry,
|
||||
} from "./workspace-registry.js";
|
||||
import { createRealpathAwarePathMatcher } from "../utils/path.js";
|
||||
import { createRealpathAwarePathMatcher, isRealpathInsideRoot } from "../utils/path.js";
|
||||
import { runWithGitCommandPriority } from "../utils/run-git-command.js";
|
||||
import { WorkspaceAutomationBlockedError } from "./workspace-automation-gate.js";
|
||||
import type { PluginWorktreeManagerRuntime } from "./plugins/runtime.js";
|
||||
import type { WorkspaceArchiveOperations } from "./workspace-archive-operations.js";
|
||||
|
||||
export type ActiveWorkspaceRef = Pick<
|
||||
PersistedWorkspaceRecord,
|
||||
"workspaceId" | "cwd" | "kind" | "worktreeRoot" | "isPaseoOwnedWorktree" | "mainRepoRoot"
|
||||
>;
|
||||
> & {
|
||||
worktreeManagerPluginId?: string | null;
|
||||
untrustedSource?: PersistedWorkspaceRecord["untrustedSource"];
|
||||
};
|
||||
|
||||
export interface ArchiveDependencies {
|
||||
paseoHome?: string;
|
||||
// Base directory that may hold worktrees across repositories.
|
||||
paseoWorktreesBaseRoot?: string;
|
||||
worktreeManagers?: Pick<PluginWorktreeManagerRuntime, "removeWorktree">;
|
||||
workspaceArchiveOperations?: Pick<WorkspaceArchiveOperations, "withCheckout">;
|
||||
github: ForgeService;
|
||||
workspaceGitService: Pick<WorkspaceGitService, "getSnapshot" | "invalidateWorktrees">;
|
||||
agentManager: Pick<AgentManager, "listAgents" | "getAgent" | "archiveAgent" | "archiveSnapshot">;
|
||||
@@ -53,6 +60,7 @@ export interface ArchiveDependencies {
|
||||
killTerminalsForWorkspace: (workspaceId: string) => Promise<void>;
|
||||
stopWorkspaceSetup?: (workspaceId: string) => Promise<void>;
|
||||
assertWorkspaceAutomationAllowed?: (workspaceId: string) => Promise<void>;
|
||||
isCheckoutUntrusted?: (checkoutPath: string) => Promise<boolean>;
|
||||
sessionLogger?: Logger;
|
||||
}
|
||||
|
||||
@@ -119,6 +127,8 @@ interface BackingDirectory {
|
||||
registryProven: boolean;
|
||||
mainRepoRoot: string | null;
|
||||
paseoWorktreesRoot: string | null;
|
||||
worktreeManagerPluginId: string | null;
|
||||
untrusted: boolean;
|
||||
}
|
||||
|
||||
interface ArchiveTarget {
|
||||
@@ -142,6 +152,13 @@ export async function resolveWorkspaceIdAtPath(
|
||||
return dependencies.findWorkspaceIdForCwd(targetPath);
|
||||
}
|
||||
|
||||
export async function resolveWorkspaceBackingPath(
|
||||
workspace: ActiveWorkspaceRef,
|
||||
dependencies: Pick<ArchiveDependencies, "paseoHome" | "paseoWorktreesBaseRoot">,
|
||||
): Promise<string> {
|
||||
return (await resolveWorkspaceBackingDirectory(workspace, dependencies)).path;
|
||||
}
|
||||
|
||||
// Resolves the in-scope record set, tears each down
|
||||
// (agents + terminals + record), then removes the backing directory iff it is
|
||||
// Paseo-owned AND no active workspace still references it.
|
||||
@@ -164,69 +181,98 @@ async function archiveByScopeWithPriority(
|
||||
};
|
||||
|
||||
checkpoint();
|
||||
const target = await resolveArchiveTarget(dependencies, request.scope);
|
||||
const targetWorkspaceIds = target.workspaceIds;
|
||||
const runArchive = async (): Promise<ArchiveResult> => {
|
||||
checkpoint();
|
||||
const target = await resolveArchiveTarget(dependencies, request.scope);
|
||||
const targetWorkspaceIds = target.workspaceIds;
|
||||
|
||||
await stopWorkspaceSetups(dependencies, target.setupWorkspaceIds, request.requestId);
|
||||
checkpoint();
|
||||
await stopWorkspaceSetups(dependencies, target.setupWorkspaceIds, request.requestId);
|
||||
checkpoint();
|
||||
|
||||
if (targetWorkspaceIds.length > 0) {
|
||||
dependencies.markWorkspaceArchiving(targetWorkspaceIds, new Date().toISOString());
|
||||
}
|
||||
|
||||
let removedDirectory = false;
|
||||
let directoryLeftBehind: ArchiveResult["directoryLeftBehind"];
|
||||
|
||||
try {
|
||||
if (targetWorkspaceIds.length > 0) {
|
||||
await dependencies.emitWorkspaceUpdatesForWorkspaceIds(targetWorkspaceIds);
|
||||
dependencies.markWorkspaceArchiving(targetWorkspaceIds, new Date().toISOString());
|
||||
}
|
||||
checkpoint();
|
||||
|
||||
const { archivedAgents, archivedWorkspaceIds } = await archiveTargetRecords(
|
||||
dependencies,
|
||||
targetWorkspaceIds,
|
||||
{ requestId: request.requestId, checkpoint, archivedAt },
|
||||
);
|
||||
checkpoint();
|
||||
let removedDirectory = false;
|
||||
let directoryLeftBehind: ArchiveResult["directoryLeftBehind"];
|
||||
|
||||
if (target.backing?.mainRepoRoot) {
|
||||
try {
|
||||
await dependencies.workspaceGitService.getSnapshot(target.backing.mainRepoRoot, {
|
||||
force: true,
|
||||
reason: "archive-worktree",
|
||||
});
|
||||
} catch (error) {
|
||||
dependencies.sessionLogger?.warn(
|
||||
{ err: error, cwd: target.backing.mainRepoRoot, requestId: request.requestId },
|
||||
"Failed to force-refresh workspace git snapshot after archiving",
|
||||
try {
|
||||
if (targetWorkspaceIds.length > 0) {
|
||||
await dependencies.emitWorkspaceUpdatesForWorkspaceIds(targetWorkspaceIds);
|
||||
}
|
||||
checkpoint();
|
||||
|
||||
const { archivedAgents, archivedWorkspaceIds } = await archiveTargetRecords(
|
||||
dependencies,
|
||||
targetWorkspaceIds,
|
||||
{ requestId: request.requestId, checkpoint, archivedAt },
|
||||
);
|
||||
checkpoint();
|
||||
|
||||
if (target.backing?.mainRepoRoot) {
|
||||
try {
|
||||
await dependencies.workspaceGitService.getSnapshot(target.backing.mainRepoRoot, {
|
||||
force: true,
|
||||
reason: "archive-worktree",
|
||||
});
|
||||
} catch (error) {
|
||||
dependencies.sessionLogger?.warn(
|
||||
{ err: error, cwd: target.backing.mainRepoRoot, requestId: request.requestId },
|
||||
"Failed to force-refresh workspace git snapshot after archiving",
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
if (target.backing !== null) {
|
||||
const removal = await maybeRemoveDirectory(
|
||||
dependencies,
|
||||
{ requestId: request.requestId, checkpoint },
|
||||
target,
|
||||
archivedWorkspaceIds,
|
||||
);
|
||||
removedDirectory = removal.removedDirectory;
|
||||
directoryLeftBehind = removal.directoryLeftBehind;
|
||||
}
|
||||
|
||||
return {
|
||||
archivedAgentIds: Array.from(archivedAgents),
|
||||
archivedWorkspaceIds,
|
||||
removedDirectory,
|
||||
...(directoryLeftBehind ? { directoryLeftBehind } : {}),
|
||||
};
|
||||
} finally {
|
||||
if (targetWorkspaceIds.length > 0) {
|
||||
dependencies.clearWorkspaceArchiving(targetWorkspaceIds);
|
||||
await dependencies.emitWorkspaceUpdatesForWorkspaceIds(targetWorkspaceIds);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
if (target.backing !== null) {
|
||||
const removal = await maybeRemoveDirectory(
|
||||
dependencies,
|
||||
{ requestId: request.requestId, checkpoint },
|
||||
target,
|
||||
archivedWorkspaceIds,
|
||||
);
|
||||
removedDirectory = removal.removedDirectory;
|
||||
directoryLeftBehind = removal.directoryLeftBehind;
|
||||
}
|
||||
|
||||
return {
|
||||
archivedAgentIds: Array.from(archivedAgents),
|
||||
archivedWorkspaceIds,
|
||||
removedDirectory,
|
||||
...(directoryLeftBehind ? { directoryLeftBehind } : {}),
|
||||
};
|
||||
} finally {
|
||||
if (targetWorkspaceIds.length > 0) {
|
||||
dependencies.clearWorkspaceArchiving(targetWorkspaceIds);
|
||||
await dependencies.emitWorkspaceUpdatesForWorkspaceIds(targetWorkspaceIds);
|
||||
}
|
||||
const checkoutPath = dependencies.workspaceArchiveOperations
|
||||
? await resolveArchiveCheckoutPath(dependencies, request.scope)
|
||||
: null;
|
||||
if (dependencies.workspaceArchiveOperations && checkoutPath) {
|
||||
return dependencies.workspaceArchiveOperations.withCheckout(checkoutPath, runArchive);
|
||||
}
|
||||
return runArchive();
|
||||
}
|
||||
|
||||
async function resolveArchiveCheckoutPath(
|
||||
dependencies: ArchiveDependencies,
|
||||
scope: ArchiveScope,
|
||||
): Promise<string | null> {
|
||||
if (scope.kind === "workspace") {
|
||||
const record =
|
||||
(await dependencies.getWorkspace?.(scope.workspaceId)) ??
|
||||
(await dependencies.listActiveWorkspaces()).find(
|
||||
(workspace) => workspace.workspaceId === scope.workspaceId,
|
||||
);
|
||||
if (!record) {
|
||||
return null;
|
||||
}
|
||||
return resolveWorkspaceBackingPath(record, dependencies);
|
||||
}
|
||||
return (await resolveBackingDirectory(scope.targetPath, dependencies)).path;
|
||||
}
|
||||
|
||||
async function resolveArchiveTarget(
|
||||
@@ -313,6 +359,8 @@ async function resolveWorkspaceBackingDirectory(
|
||||
workspace: ActiveWorkspaceRef,
|
||||
dependencies: Pick<ArchiveDependencies, "paseoHome" | "paseoWorktreesBaseRoot">,
|
||||
): Promise<BackingDirectory> {
|
||||
const worktreeManagerPluginId = workspace.worktreeManagerPluginId ?? null;
|
||||
const untrusted = Boolean(workspace.untrustedSource);
|
||||
if (workspace.isPaseoOwnedWorktree === false) {
|
||||
return {
|
||||
path: resolve(workspace.worktreeRoot ?? workspace.cwd),
|
||||
@@ -321,6 +369,8 @@ async function resolveWorkspaceBackingDirectory(
|
||||
registryProven: false,
|
||||
mainRepoRoot: workspace.mainRepoRoot ?? null,
|
||||
paseoWorktreesRoot: null,
|
||||
worktreeManagerPluginId,
|
||||
untrusted,
|
||||
};
|
||||
}
|
||||
if (workspace.isPaseoOwnedWorktree && workspace.worktreeRoot && workspace.mainRepoRoot) {
|
||||
@@ -331,6 +381,8 @@ async function resolveWorkspaceBackingDirectory(
|
||||
registryProven: true,
|
||||
mainRepoRoot: workspace.mainRepoRoot,
|
||||
paseoWorktreesRoot: null,
|
||||
worktreeManagerPluginId,
|
||||
untrusted,
|
||||
};
|
||||
}
|
||||
if (workspace.kind !== "worktree") {
|
||||
@@ -341,6 +393,8 @@ async function resolveWorkspaceBackingDirectory(
|
||||
registryProven: false,
|
||||
mainRepoRoot: workspace.mainRepoRoot ?? null,
|
||||
paseoWorktreesRoot: null,
|
||||
worktreeManagerPluginId,
|
||||
untrusted,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -350,7 +404,12 @@ async function resolveWorkspaceBackingDirectory(
|
||||
workspace.worktreeRoot ?? workspace.cwd,
|
||||
dependencies,
|
||||
);
|
||||
return { ...backing, mainRepoRoot: workspace.mainRepoRoot ?? backing.mainRepoRoot };
|
||||
return {
|
||||
...backing,
|
||||
mainRepoRoot: workspace.mainRepoRoot ?? backing.mainRepoRoot,
|
||||
worktreeManagerPluginId: worktreeManagerPluginId ?? backing.worktreeManagerPluginId,
|
||||
untrusted: untrusted || backing.untrusted,
|
||||
};
|
||||
}
|
||||
|
||||
async function resolveBackingDirectory(
|
||||
@@ -369,6 +428,8 @@ async function resolveBackingDirectory(
|
||||
registryProven: false,
|
||||
mainRepoRoot: ownership.repoRoot ?? null,
|
||||
paseoWorktreesRoot: ownership.worktreeRoot ?? null,
|
||||
worktreeManagerPluginId: null,
|
||||
untrusted: false,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -453,11 +514,16 @@ async function maybeRemoveDirectory(
|
||||
teardownTarget.workspaceId === null || archivedWorkspaceIdSet.has(teardownTarget.workspaceId),
|
||||
);
|
||||
|
||||
let untrustedBacking =
|
||||
backing.untrusted || Boolean(await dependencies.isCheckoutUntrusted?.(backing.path));
|
||||
try {
|
||||
const allowedTeardownTargets = await filterAllowedTeardownTargets(
|
||||
dependencies,
|
||||
teardownTargets,
|
||||
);
|
||||
if (allowedTeardownTargets.length < teardownTargets.length) {
|
||||
untrustedBacking = true;
|
||||
}
|
||||
for (const teardownTarget of uniqueTeardownTargets(allowedTeardownTargets)) {
|
||||
request.checkpoint();
|
||||
await runWorktreeTeardownCommands({
|
||||
@@ -501,6 +567,10 @@ async function maybeRemoveDirectory(
|
||||
paseoHome: dependencies.paseoHome,
|
||||
worktreesBaseRoot: dependencies.paseoWorktreesBaseRoot,
|
||||
registryProven: backing.registryProven,
|
||||
worktreeManagers: dependencies.worktreeManagers,
|
||||
worktreeManagerPluginId: backing.worktreeManagerPluginId,
|
||||
removeReason: "archive",
|
||||
untrusted: untrustedBacking,
|
||||
});
|
||||
dependencies.workspaceGitService.invalidateWorktrees();
|
||||
dependencies.github.invalidate({ cwd: backing.path });
|
||||
@@ -619,7 +689,7 @@ export async function archiveWorkspaceContents(
|
||||
}
|
||||
|
||||
// True when, after archiving
|
||||
// the in-scope records, no active workspace still points at targetDir. Derived
|
||||
// the in-scope records, no active workspace still points at or inside targetDir. Derived
|
||||
// from records each call — no stored counter.
|
||||
async function isDirectoryUnreferenced(
|
||||
activeWorkspaces: ActiveWorkspaceRef[],
|
||||
@@ -632,7 +702,13 @@ async function isDirectoryUnreferenced(
|
||||
for (const workspace of activeWorkspaces) {
|
||||
if (archivedWorkspaceIds.has(workspace.workspaceId)) continue;
|
||||
const backingDirectory = await resolveWorkspaceBackingDirectory(workspace, dependencies);
|
||||
if (matchesTarget(backingDirectory.path)) return false;
|
||||
if (
|
||||
matchesTarget(backingDirectory.path) ||
|
||||
isRealpathInsideRoot(target, backingDirectory.path) ||
|
||||
isRealpathInsideRoot(target, workspace.cwd)
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import { createRealpathAwarePathMatcher } from "../utils/path.js";
|
||||
import type { WorkspaceRegistry } from "./workspace-registry.js";
|
||||
|
||||
export interface UntrustedWorkspaceSource {
|
||||
@@ -34,17 +35,44 @@ export async function assertWorkspaceAutomationAllowedForWorkspace(
|
||||
assertWorkspaceAutomationAllowed(workspace.untrustedSource);
|
||||
}
|
||||
|
||||
export async function isCheckoutUntrusted(
|
||||
registry: Pick<WorkspaceRegistry, "listAll">,
|
||||
checkoutPath: string,
|
||||
): Promise<boolean> {
|
||||
const matchesCheckout = createRealpathAwarePathMatcher(checkoutPath);
|
||||
const workspaces = await registry.listAll();
|
||||
return workspaces.some(
|
||||
(workspace) =>
|
||||
Boolean(workspace.untrustedSource) &&
|
||||
matchesCheckout(workspace.worktreeRoot ?? workspace.cwd),
|
||||
);
|
||||
}
|
||||
|
||||
export async function clearWorkspaceAutomationBlock(
|
||||
registry: Pick<WorkspaceRegistry, "update">,
|
||||
registry: Pick<WorkspaceRegistry, "update" | "listAll">,
|
||||
workspaceId: string,
|
||||
): Promise<boolean> {
|
||||
let cleared = false;
|
||||
const timestamp = new Date().toISOString();
|
||||
const workspace = await registry.update(workspaceId, (record) => {
|
||||
if (!record.untrustedSource) return record;
|
||||
cleared = true;
|
||||
const { untrustedSource: _removed, ...trusted } = record;
|
||||
return { ...trusted, updatedAt: new Date().toISOString() };
|
||||
return { ...trusted, updatedAt: timestamp };
|
||||
});
|
||||
if (!workspace) throw new Error(`Workspace not found: ${workspaceId}`);
|
||||
const checkoutPath = workspace.worktreeRoot ?? workspace.cwd;
|
||||
const matchesCheckout = createRealpathAwarePathMatcher(checkoutPath);
|
||||
const siblings = await registry.listAll();
|
||||
for (const sibling of siblings) {
|
||||
if (sibling.workspaceId === workspaceId || !sibling.untrustedSource) continue;
|
||||
if (!matchesCheckout(sibling.worktreeRoot ?? sibling.cwd)) continue;
|
||||
await registry.update(sibling.workspaceId, (record) => {
|
||||
if (!record.untrustedSource) return record;
|
||||
cleared = true;
|
||||
const { untrustedSource: _removed, ...trusted } = record;
|
||||
return { ...trusted, updatedAt: timestamp };
|
||||
});
|
||||
}
|
||||
return cleared;
|
||||
}
|
||||
|
||||
@@ -88,6 +88,7 @@ const PersistedWorkspaceRecordSchema = z.object({
|
||||
.transform((value) => value ?? null),
|
||||
isPaseoOwnedWorktree: z.boolean().default(false),
|
||||
mainRepoRoot: z.string().nullable().default(null),
|
||||
worktreeManagerPluginId: z.string().min(1).optional(),
|
||||
createdAt: z.string(),
|
||||
updatedAt: z.string(),
|
||||
archivedAt: z.string().nullable(),
|
||||
@@ -698,6 +699,7 @@ export function createPersistedWorkspaceRecord(input: {
|
||||
baseBranch?: string | null;
|
||||
isPaseoOwnedWorktree?: boolean;
|
||||
mainRepoRoot?: string | null;
|
||||
worktreeManagerPluginId?: string | null;
|
||||
createdAt: string;
|
||||
updatedAt: string;
|
||||
archivedAt?: string | null;
|
||||
@@ -708,7 +710,7 @@ export function createPersistedWorkspaceRecord(input: {
|
||||
untrustedSource?: UntrustedWorkspaceSource;
|
||||
background?: boolean;
|
||||
}): PersistedWorkspaceRecord {
|
||||
const { background, ...rest } = input;
|
||||
const { background, worktreeManagerPluginId, ...rest } = input;
|
||||
return PersistedWorkspaceRecordSchema.parse({
|
||||
...rest,
|
||||
background: background ?? false,
|
||||
@@ -718,6 +720,7 @@ export function createPersistedWorkspaceRecord(input: {
|
||||
baseBranch: input.baseBranch ?? null,
|
||||
isPaseoOwnedWorktree: input.isPaseoOwnedWorktree ?? false,
|
||||
mainRepoRoot: input.mainRepoRoot ?? null,
|
||||
...(worktreeManagerPluginId ? { worktreeManagerPluginId } : {}),
|
||||
archivedAt: input.archivedAt ?? null,
|
||||
autoArchivedChangeRequestUrl: input.autoArchivedChangeRequestUrl ?? null,
|
||||
pinnedAt: input.pinnedAt ?? null,
|
||||
|
||||
@@ -25,9 +25,15 @@ import {
|
||||
readPaseoWorktreeMetadata,
|
||||
} from "../utils/worktree-metadata.js";
|
||||
import { validateBeforeRequest, validateBeforeResult } from "./plugins/lifecycle/index.js";
|
||||
import { UnknownBranchError } from "../utils/worktree.js";
|
||||
import {
|
||||
isPaseoOwnedWorktreeCwd,
|
||||
listGitWorktrees,
|
||||
listPaseoWorktrees,
|
||||
UnknownBranchError,
|
||||
} from "../utils/worktree.js";
|
||||
import { createWorktreeCore as createCoreWorktree } from "./worktree-core.js";
|
||||
import { isPlatform } from "../test-utils/platform.js";
|
||||
import { createWithWorktrunk } from "../../../../plugin-examples/worktrunk/server/wt.js";
|
||||
|
||||
function createGitHubServiceStub(): ForgeService {
|
||||
return {
|
||||
@@ -1035,6 +1041,87 @@ describe.skipIf(isPlatform("win32"))("worktree-core POSIX-only", () => {
|
||||
expect(getBranchUpstream(result.worktree.worktreePath)).toBeNull();
|
||||
});
|
||||
|
||||
test.each([true, false])(
|
||||
"checks out the fetched PR head with local branch collision=%s",
|
||||
async (collision) => {
|
||||
const { tempDir, repoDir, remoteDir, paseoHome } = createSameRepoGitHubPrRemoteRepo();
|
||||
cleanupPaths.push(tempDir);
|
||||
const branch = "daemon-shutdown-diagnostics";
|
||||
const cached = execFileSync("git", ["rev-parse", "main"], {
|
||||
cwd: repoDir,
|
||||
encoding: "utf8",
|
||||
}).trim();
|
||||
if (collision) execFileSync("git", ["branch", "-f", branch, cached], { cwd: repoDir });
|
||||
const expected = execFileSync(
|
||||
"git",
|
||||
["--git-dir", remoteDir, "rev-parse", "refs/pull/1790/head"],
|
||||
{ encoding: "utf8" },
|
||||
).trim();
|
||||
expect(cached).not.toBe(expected);
|
||||
|
||||
const wt = path.join(tempDir, "wt");
|
||||
writeFileSync(
|
||||
wt,
|
||||
`#!/bin/sh
|
||||
if [ "$3" = remove ]; then
|
||||
exec git -C "$2" worktree remove --force "$2-pr-checkout"
|
||||
fi
|
||||
repo="$2"
|
||||
shift 2
|
||||
branch=""
|
||||
base=""
|
||||
while [ "$#" -gt 0 ]; do
|
||||
case "$1" in
|
||||
--create) branch="$2"; shift 2 ;;
|
||||
--base) base="$2"; shift 2 ;;
|
||||
*) shift ;;
|
||||
esac
|
||||
done
|
||||
git -C "$repo" worktree add --quiet -b "$branch" "$repo-pr-checkout" "$base" || exit $?
|
||||
printf '{"action":"created","path":"%s","branch":"%s","created_branch":true}\\n' "$repo-pr-checkout" "$branch"
|
||||
printf 'setup' > "$repo-pr-checkout/.worktrunk-setup"
|
||||
`,
|
||||
{ mode: 0o755 },
|
||||
);
|
||||
const previous = process.env.WORKTRUNK_BIN;
|
||||
process.env.WORKTRUNK_BIN = wt;
|
||||
try {
|
||||
const result = await createCoreWorktree(
|
||||
{ cwd: repoDir, action: "checkout", refName: branch, githubPrNumber: 1790, paseoHome },
|
||||
{
|
||||
...createCoreDeps(),
|
||||
worktreeManagers: {
|
||||
hasWorktreeManager: () => true,
|
||||
createWorktree: async (request) => {
|
||||
const managed = await createWithWorktrunk(request, new AbortController().signal);
|
||||
return managed ? { pluginId: "worktrunk", path: managed.path } : null;
|
||||
},
|
||||
removeWorktree: async () => null,
|
||||
},
|
||||
},
|
||||
);
|
||||
expect(
|
||||
execFileSync("git", ["rev-parse", "HEAD"], {
|
||||
cwd: result.worktree.worktreePath,
|
||||
encoding: "utf8",
|
||||
}).trim(),
|
||||
).toBe(expected);
|
||||
expect(
|
||||
execFileSync("git", ["rev-parse", `refs/heads/${branch}`], {
|
||||
cwd: repoDir,
|
||||
encoding: "utf8",
|
||||
}).trim(),
|
||||
).toBe(collision ? cached : expected);
|
||||
expect(existsSync(path.join(result.worktree.worktreePath, ".worktrunk-setup"))).toBe(
|
||||
!collision,
|
||||
);
|
||||
} finally {
|
||||
if (previous === undefined) delete process.env.WORKTRUNK_BIN;
|
||||
else process.env.WORKTRUNK_BIN = previous;
|
||||
}
|
||||
},
|
||||
);
|
||||
|
||||
test("pushes a deduplicated same-repo GitHub PR branch to the PR head", async () => {
|
||||
const { tempDir, repoDir, remoteDir, paseoHome } = createSameRepoGitHubPrRemoteRepo();
|
||||
cleanupPaths.push(tempDir);
|
||||
@@ -1467,6 +1554,454 @@ describe.skipIf(isPlatform("win32"))("worktree-core POSIX-only", () => {
|
||||
expect(getBranchUpstream(second.worktree.worktreePath)).toBe("paseo-pr-526/main");
|
||||
});
|
||||
|
||||
test("rejects and rolls back a managed fork PR checkout whose HEAD is behind the current PR head", async () => {
|
||||
const { tempDir, repoDir, headRemoteDir, paseoHome } = createForkGitHubPrRemoteRepo();
|
||||
cleanupPaths.push(tempDir);
|
||||
const staleBranch = "archived-fork-pr-526";
|
||||
const staleWorktreePath = path.join(tempDir, "stale-fork-pr");
|
||||
git(repoDir, "branch", staleBranch, "main");
|
||||
const github = {
|
||||
...createGitHubServiceStub(),
|
||||
getPullRequestCheckoutTarget: async () => ({
|
||||
number: 526,
|
||||
baseRefName: "main",
|
||||
headRefName: "main",
|
||||
headOwnerLogin: "therainisme",
|
||||
headRepositorySshUrl: headRemoteDir,
|
||||
headRepositoryUrl: headRemoteDir,
|
||||
isCrossRepository: true,
|
||||
}),
|
||||
};
|
||||
|
||||
await expect(
|
||||
createCoreWorktree(
|
||||
{
|
||||
cwd: repoDir,
|
||||
worktreeSlug: "fork-pr-stale",
|
||||
action: "checkout",
|
||||
githubPrNumber: 526,
|
||||
refName: "main",
|
||||
paseoHome,
|
||||
},
|
||||
{
|
||||
...createCoreDeps({ github }),
|
||||
worktreeManagers: {
|
||||
hasWorktreeManager: () => true,
|
||||
createWorktree: async () => {
|
||||
git(repoDir, "worktree", "add", staleWorktreePath, staleBranch);
|
||||
return { pluginId: "stale-manager", path: staleWorktreePath };
|
||||
},
|
||||
removeWorktree: async () => null,
|
||||
},
|
||||
},
|
||||
),
|
||||
).rejects.toThrow("expected change request head");
|
||||
expect(existsSync(staleWorktreePath)).toBe(false);
|
||||
});
|
||||
|
||||
test("fails before calling the manager when the remote PR ref cannot be fetched", async () => {
|
||||
const { tempDir, repoDir, headRemoteDir, paseoHome } = createForkGitHubPrRemoteRepo();
|
||||
cleanupPaths.push(tempDir);
|
||||
let managerCalled = false;
|
||||
git(repoDir, "remote", "set-url", "origin", path.join(tempDir, "missing-remote.git"));
|
||||
const github = {
|
||||
...createGitHubServiceStub(),
|
||||
getPullRequestCheckoutTarget: async () => ({
|
||||
number: 526,
|
||||
baseRefName: "main",
|
||||
headRefName: "main",
|
||||
headOwnerLogin: "therainisme",
|
||||
headRepositorySshUrl: headRemoteDir,
|
||||
headRepositoryUrl: headRemoteDir,
|
||||
isCrossRepository: true,
|
||||
}),
|
||||
};
|
||||
|
||||
await expect(
|
||||
createCoreWorktree(
|
||||
{
|
||||
cwd: repoDir,
|
||||
worktreeSlug: "fork-pr-offline",
|
||||
action: "checkout",
|
||||
githubPrNumber: 526,
|
||||
refName: "main",
|
||||
paseoHome,
|
||||
},
|
||||
{
|
||||
...createCoreDeps({ github }),
|
||||
worktreeManagers: {
|
||||
hasWorktreeManager: () => true,
|
||||
createWorktree: async () => {
|
||||
managerCalled = true;
|
||||
return null;
|
||||
},
|
||||
removeWorktree: async () => null,
|
||||
},
|
||||
},
|
||||
),
|
||||
).rejects.toThrow("Unable to fetch change request refs");
|
||||
expect(managerCalled).toBe(false);
|
||||
});
|
||||
|
||||
test("accepts a managed fork PR checkout matching the pre-fetched headSha even after multiple mid-setup pushes", async () => {
|
||||
const { tempDir, repoDir, headRemoteDir, paseoHome } = createForkGitHubPrRemoteRepo();
|
||||
cleanupPaths.push(tempDir);
|
||||
const baseRemoteDir = path.join(tempDir, "base.git");
|
||||
const initialPrHead = git(repoDir, "ls-remote", "origin", "refs/pull/526/head").split(
|
||||
/\s+/,
|
||||
)[0];
|
||||
const managedPath = path.join(tempDir, "mid-push-fork-pr");
|
||||
const github = {
|
||||
...createGitHubServiceStub(),
|
||||
getPullRequestCheckoutTarget: async () => ({
|
||||
number: 526,
|
||||
baseRefName: "main",
|
||||
headRefName: "main",
|
||||
headOwnerLogin: "therainisme",
|
||||
headRepositorySshUrl: headRemoteDir,
|
||||
headRepositoryUrl: headRemoteDir,
|
||||
isCrossRepository: true,
|
||||
}),
|
||||
};
|
||||
|
||||
const pushCommit = (message: string) => {
|
||||
const headCloneDir = path.join(tempDir, "therainisme-clone");
|
||||
writeFileSync(path.join(headCloneDir, "README.md"), `${message}\n`);
|
||||
git(headCloneDir, "add", "README.md");
|
||||
git(headCloneDir, "-c", "commit.gpgsign=false", "commit", "-m", message);
|
||||
const head = git(headCloneDir, "rev-parse", "HEAD");
|
||||
git(headCloneDir, "push", "origin", "main");
|
||||
execFileSync("git", [`--git-dir=${baseRemoteDir}`, "fetch", headRemoteDir, "main"], {
|
||||
stdio: "pipe",
|
||||
});
|
||||
execFileSync(
|
||||
"git",
|
||||
[`--git-dir=${baseRemoteDir}`, "update-ref", "refs/pull/526/head", head],
|
||||
{ stdio: "pipe" },
|
||||
);
|
||||
};
|
||||
|
||||
const result = await createCoreWorktree(
|
||||
{
|
||||
cwd: repoDir,
|
||||
worktreeSlug: "fork-pr-mid-push",
|
||||
action: "checkout",
|
||||
githubPrNumber: 526,
|
||||
refName: "main",
|
||||
paseoHome,
|
||||
},
|
||||
{
|
||||
...createCoreDeps({ github }),
|
||||
worktreeManagers: {
|
||||
hasWorktreeManager: () => true,
|
||||
createWorktree: async (request) => {
|
||||
expect(request.headSha).toBe(initialPrHead);
|
||||
// Two pushes happen while the manager creates the worktree from request.headSha.
|
||||
pushCommit("mid-setup push B");
|
||||
git(repoDir, "worktree", "add", "-b", "pr-526-snap", managedPath, request.headSha!);
|
||||
pushCommit("mid-setup push C");
|
||||
return { pluginId: "mid-push-manager", path: managedPath };
|
||||
},
|
||||
removeWorktree: async () => null,
|
||||
},
|
||||
},
|
||||
);
|
||||
|
||||
expect(git(result.worktree.worktreePath, "rev-parse", "HEAD")).toBe(initialPrHead);
|
||||
});
|
||||
|
||||
test("configures fork push remote on a managed Worktrunk PR checkout so Push updates the fork branch", async () => {
|
||||
const { tempDir, repoDir, headRemoteDir, paseoHome } = createForkGitHubPrRemoteRepo();
|
||||
cleanupPaths.push(tempDir);
|
||||
const baseRemoteDir = path.join(tempDir, "base.git");
|
||||
const wt = path.join(tempDir, "fake-wt-fork-push");
|
||||
writeFileSync(
|
||||
wt,
|
||||
`#!/bin/sh
|
||||
repo="$2"
|
||||
shift 2
|
||||
branch=""
|
||||
base=""
|
||||
while [ "$#" -gt 0 ]; do
|
||||
case "$1" in
|
||||
--create) branch="$2"; shift 2 ;;
|
||||
--base) base="$2"; shift 2 ;;
|
||||
*) shift ;;
|
||||
esac
|
||||
done
|
||||
git -C "$repo" worktree add --quiet -b "$branch" "$repo-fork-managed" "$base" || exit $?
|
||||
printf '{"action":"created","path":"%s","branch":"%s","created_branch":true}\\n' "$repo-fork-managed" "$branch"
|
||||
`,
|
||||
{ mode: 0o755 },
|
||||
);
|
||||
|
||||
const github = {
|
||||
...createGitHubServiceStub(),
|
||||
getPullRequestCheckoutTarget: async () => ({
|
||||
number: 526,
|
||||
baseRefName: "main",
|
||||
headRefName: "main",
|
||||
headOwnerLogin: "therainisme",
|
||||
headRepositorySshUrl: headRemoteDir,
|
||||
headRepositoryUrl: headRemoteDir,
|
||||
isCrossRepository: true,
|
||||
}),
|
||||
};
|
||||
|
||||
const previous = process.env.WORKTRUNK_BIN;
|
||||
process.env.WORKTRUNK_BIN = wt;
|
||||
try {
|
||||
const result = await createCoreWorktree(
|
||||
{
|
||||
cwd: repoDir,
|
||||
worktreeSlug: "fork-pr-managed-push",
|
||||
action: "checkout",
|
||||
githubPrNumber: 526,
|
||||
refName: "main",
|
||||
paseoHome,
|
||||
},
|
||||
{
|
||||
...createCoreDeps({ github }),
|
||||
worktreeManagers: {
|
||||
hasWorktreeManager: () => true,
|
||||
createWorktree: async (request) => {
|
||||
const managed = await createWithWorktrunk(request, new AbortController().signal);
|
||||
return managed ? { pluginId: "worktrunk", path: managed.path } : null;
|
||||
},
|
||||
removeWorktree: async () => null,
|
||||
},
|
||||
},
|
||||
);
|
||||
expect(result.worktree.worktreeManagerPluginId).toBe("worktrunk");
|
||||
expect(result.worktree.branchName).toBe("therainisme/main");
|
||||
writeFileSync(path.join(result.worktree.worktreePath, "README.md"), "pushed from wt\n");
|
||||
git(result.worktree.worktreePath, "add", "README.md");
|
||||
git(
|
||||
result.worktree.worktreePath,
|
||||
"-c",
|
||||
"commit.gpgsign=false",
|
||||
"commit",
|
||||
"-m",
|
||||
"managed fork commit",
|
||||
);
|
||||
const pushedSha = git(result.worktree.worktreePath, "rev-parse", "HEAD");
|
||||
await pushCurrentBranch(result.worktree.worktreePath);
|
||||
|
||||
expect(
|
||||
execFileSync("git", [`--git-dir=${headRemoteDir}`, "rev-parse", "refs/heads/main"], {
|
||||
encoding: "utf8",
|
||||
}).trim(),
|
||||
).toBe(pushedSha);
|
||||
expect(
|
||||
execFileSync(
|
||||
"git",
|
||||
[`--git-dir=${baseRemoteDir}`, "for-each-ref", "refs/heads/therainisme/main"],
|
||||
{ encoding: "utf8" },
|
||||
).trim(),
|
||||
).toBe("");
|
||||
} finally {
|
||||
if (previous === undefined) delete process.env.WORKTRUNK_BIN;
|
||||
else process.env.WORKTRUNK_BIN = previous;
|
||||
}
|
||||
});
|
||||
|
||||
test("falls back to built-in Git without calling managers when Git rejects worktree list -z", async () => {
|
||||
const { tempDir, repoDir, paseoHome } = createGitRepo();
|
||||
cleanupPaths.push(tempDir);
|
||||
const trailingSpaceWorktree = path.join(tempDir, "detached space ");
|
||||
git(repoDir, "worktree", "add", "--detach", trailingSpaceWorktree, "main");
|
||||
writeFileSync(path.join(trailingSpaceWorktree, "keep.txt"), "do not delete\n");
|
||||
|
||||
const realGit = execFileSync("which", ["git"], { encoding: "utf8" }).trim();
|
||||
const shimDir = path.join(tempDir, "legacy-git-bin");
|
||||
mkdirSync(shimDir, { recursive: true });
|
||||
writeFileSync(
|
||||
path.join(shimDir, "git"),
|
||||
`#!/bin/sh
|
||||
for arg in "$@"; do
|
||||
if [ "$arg" = "-z" ]; then
|
||||
echo 'error: unknown switch -z' >&2
|
||||
exit 129
|
||||
fi
|
||||
done
|
||||
exec "${realGit}" "$@"
|
||||
`,
|
||||
{ mode: 0o755 },
|
||||
);
|
||||
|
||||
let managerCalled = false;
|
||||
const previousPath = process.env.PATH;
|
||||
process.env.PATH = `${shimDir}:${previousPath ?? ""}`;
|
||||
try {
|
||||
const result = await createCoreWorktree(
|
||||
{
|
||||
cwd: repoDir,
|
||||
worktreeSlug: "legacy-git-fallback",
|
||||
action: "branch-off",
|
||||
branchName: "legacy-git-fallback",
|
||||
paseoHome,
|
||||
},
|
||||
{
|
||||
...createCoreDeps(),
|
||||
worktreeManagers: {
|
||||
hasWorktreeManager: () => true,
|
||||
createWorktree: async () => {
|
||||
managerCalled = true;
|
||||
return { pluginId: "bad-manager", path: trailingSpaceWorktree };
|
||||
},
|
||||
removeWorktree: async () => null,
|
||||
},
|
||||
},
|
||||
);
|
||||
expect(managerCalled).toBe(false);
|
||||
expect(result.worktree.branchName).toBe("legacy-git-fallback");
|
||||
expect(result.worktree.worktreeManagerPluginId).toBeUndefined();
|
||||
expect(readFileSync(path.join(trailingSpaceWorktree, "keep.txt"), "utf8")).toBe(
|
||||
"do not delete\n",
|
||||
);
|
||||
} finally {
|
||||
if (previousPath === undefined) delete process.env.PATH;
|
||||
else process.env.PATH = previousPath;
|
||||
}
|
||||
});
|
||||
|
||||
test("protects pre-existing and discovers newly managed worktrees whose paths contain a line break", async () => {
|
||||
const { tempDir, repoDir, paseoHome } = createGitRepo();
|
||||
cleanupPaths.push(tempDir);
|
||||
const newlineWorktree = path.join(tempDir, "manual\nworktree");
|
||||
git(repoDir, "worktree", "add", "-b", "newline-branch", newlineWorktree, "main");
|
||||
writeFileSync(path.join(newlineWorktree, "keep.txt"), "uncommitted\n");
|
||||
|
||||
await expect(
|
||||
createCoreWorktree(
|
||||
{
|
||||
cwd: repoDir,
|
||||
worktreeSlug: "newline-hijack",
|
||||
action: "branch-off",
|
||||
branchName: "newline-hijack",
|
||||
paseoHome,
|
||||
},
|
||||
{
|
||||
...createCoreDeps(),
|
||||
worktreeManagers: {
|
||||
hasWorktreeManager: () => true,
|
||||
createWorktree: async () => ({
|
||||
pluginId: "bad-manager",
|
||||
path: newlineWorktree,
|
||||
}),
|
||||
removeWorktree: async () => null,
|
||||
},
|
||||
},
|
||||
),
|
||||
).rejects.toThrow("already-existing worktree");
|
||||
|
||||
expect(readFileSync(path.join(newlineWorktree, "keep.txt"), "utf8")).toBe("uncommitted\n");
|
||||
expect(await readPaseoWorktreeMetadata(newlineWorktree)).toBeNull();
|
||||
|
||||
// A newly created managed worktree inside a directory containing a line break must remain
|
||||
// visible to discovery and marker-based ownership checks.
|
||||
const managedNewlineDir = path.join(tempDir, "parent\nbreak", "managed-wt");
|
||||
mkdirSync(path.dirname(managedNewlineDir), { recursive: true });
|
||||
const created = await createCoreWorktree(
|
||||
{
|
||||
cwd: repoDir,
|
||||
worktreeSlug: "newline-managed",
|
||||
action: "branch-off",
|
||||
branchName: "newline-managed",
|
||||
paseoHome,
|
||||
},
|
||||
{
|
||||
...createCoreDeps(),
|
||||
worktreeManagers: {
|
||||
hasWorktreeManager: () => true,
|
||||
createWorktree: async (request) => {
|
||||
git(repoDir, "worktree", "add", "-b", request.branch, managedNewlineDir, "main");
|
||||
return { pluginId: "newline-manager", path: managedNewlineDir };
|
||||
},
|
||||
removeWorktree: async () => null,
|
||||
},
|
||||
},
|
||||
);
|
||||
|
||||
const expectedPath = realpathSync(managedNewlineDir);
|
||||
expect(created.worktree.worktreePath).toBe(expectedPath);
|
||||
const allGitWorktrees = await listGitWorktrees({ cwd: repoDir });
|
||||
expect(allGitWorktrees.map((entry) => entry.path)).toContain(expectedPath);
|
||||
const paseoWorktrees = await listPaseoWorktrees({ cwd: repoDir, paseoHome });
|
||||
expect(paseoWorktrees.map((entry) => entry.path)).toContain(expectedPath);
|
||||
const ownership = await isPaseoOwnedWorktreeCwd(expectedPath, { paseoHome });
|
||||
expect(ownership.allowed).toBe(true);
|
||||
expect(ownership.worktreePath).toBe(expectedPath);
|
||||
});
|
||||
|
||||
test("declines a Worktrunk fork PR checkout when the archived local branch already exists so Git checks out the latest PR head", async () => {
|
||||
const { tempDir, repoDir, headRemoteDir, paseoHome } = createForkGitHubPrRemoteRepo();
|
||||
cleanupPaths.push(tempDir);
|
||||
const archivedBranch = "therainisme/main";
|
||||
const archivedTip = git(repoDir, "rev-parse", "main");
|
||||
git(repoDir, "branch", archivedBranch, archivedTip);
|
||||
const latestPrHead = git(repoDir, "ls-remote", "origin", "refs/pull/526/head").split(
|
||||
/\s+/,
|
||||
)[0];
|
||||
expect(latestPrHead).not.toBe(archivedTip);
|
||||
|
||||
const wt = path.join(tempDir, "fake-wt-fork-pr");
|
||||
writeFileSync(
|
||||
wt,
|
||||
`#!/bin/sh
|
||||
echo "wt should not be invoked when local branch already exists" >&2
|
||||
exit 1
|
||||
`,
|
||||
{ mode: 0o755 },
|
||||
);
|
||||
|
||||
const github = {
|
||||
...createGitHubServiceStub(),
|
||||
getPullRequestCheckoutTarget: async () => ({
|
||||
number: 526,
|
||||
baseRefName: "main",
|
||||
headRefName: "main",
|
||||
headOwnerLogin: "therainisme",
|
||||
headRepositorySshUrl: headRemoteDir,
|
||||
headRepositoryUrl: headRemoteDir,
|
||||
isCrossRepository: true,
|
||||
}),
|
||||
};
|
||||
|
||||
const previous = process.env.WORKTRUNK_BIN;
|
||||
process.env.WORKTRUNK_BIN = wt;
|
||||
try {
|
||||
const result = await createCoreWorktree(
|
||||
{
|
||||
cwd: repoDir,
|
||||
worktreeSlug: "fork-pr-reopen",
|
||||
action: "checkout",
|
||||
githubPrNumber: 526,
|
||||
refName: "main",
|
||||
paseoHome,
|
||||
},
|
||||
{
|
||||
...createCoreDeps({ github }),
|
||||
worktreeManagers: {
|
||||
hasWorktreeManager: () => true,
|
||||
createWorktree: async (request) => {
|
||||
expect(request.untrusted).toBe(true);
|
||||
expect(request.headSha).toBe(latestPrHead);
|
||||
const managed = await createWithWorktrunk(request, new AbortController().signal);
|
||||
return managed ? { pluginId: "worktrunk", path: managed.path } : null;
|
||||
},
|
||||
removeWorktree: async () => null,
|
||||
},
|
||||
},
|
||||
);
|
||||
expect(git(result.worktree.worktreePath, "rev-parse", "HEAD")).toBe(latestPrHead);
|
||||
expect(git(repoDir, "rev-parse", `refs/heads/${archivedBranch}`)).toBe(archivedTip);
|
||||
} finally {
|
||||
if (previous === undefined) delete process.env.WORKTRUNK_BIN;
|
||||
else process.env.WORKTRUNK_BIN = previous;
|
||||
}
|
||||
});
|
||||
|
||||
test("throws a typed error for an unknown checkout branch", async () => {
|
||||
const { tempDir, repoDir, paseoHome } = createGitRepo();
|
||||
cleanupPaths.push(tempDir);
|
||||
@@ -1648,9 +2183,26 @@ describe.skipIf(isPlatform("win32"))("worktree-core POSIX-only", () => {
|
||||
branchName: "follow-up",
|
||||
paseoHome,
|
||||
},
|
||||
createCoreDeps({ github }),
|
||||
{
|
||||
...createCoreDeps({ github }),
|
||||
worktreeManagers: {
|
||||
hasWorktreeManager: () => true,
|
||||
async createWorktree(request) {
|
||||
expect(request.untrusted).toBe(true);
|
||||
return null;
|
||||
},
|
||||
async removeWorktree() {
|
||||
return null;
|
||||
},
|
||||
},
|
||||
},
|
||||
);
|
||||
|
||||
expect(result.untrustedSource).toMatchObject({
|
||||
kind: "change_request",
|
||||
forge: "github",
|
||||
number: 526,
|
||||
});
|
||||
const readme = readFileSync(path.join(result.worktree.worktreePath, "README.md"), "utf8");
|
||||
// The fork's branch is not in this repository, so a pull request from the new branch goes
|
||||
// into the fork pull request's base, compared as the remote has it now.
|
||||
|
||||
@@ -1,12 +1,19 @@
|
||||
import type { PluginWorktreeCreateRequest } from "@getpaseo/plugin/server";
|
||||
import type {
|
||||
PluginWorktreeCreateInput,
|
||||
PluginWorktreeCreateRequest,
|
||||
} from "@getpaseo/plugin/server";
|
||||
import type { PluginLifecycle } from "./plugins/lifecycle/index.js";
|
||||
import type { PluginWorktreeManagerRuntime } from "./plugins/runtime.js";
|
||||
import { createNameId } from "mnemonic-id";
|
||||
|
||||
import type { ForgeService } from "../services/forge-service.js";
|
||||
import {
|
||||
createWorktree,
|
||||
fetchFirstAvailableRef,
|
||||
prepareWorktreeBranchOff,
|
||||
type PreparedWorktreeBranchOff,
|
||||
resolveDefaultWorktreePath,
|
||||
runPluginWorktreeManagerCheckout,
|
||||
slugify,
|
||||
validateBranchSlug,
|
||||
type CreatedWorktree,
|
||||
@@ -16,11 +23,14 @@ import {
|
||||
type ResolveWorktreeCreationIntentInput,
|
||||
UnsupportedForgeCheckoutTargetError,
|
||||
type WorktreeCreationIntent,
|
||||
worktreeUntrustedSource,
|
||||
} from "./resolve-worktree-creation-intent.js";
|
||||
import type { ChangeRequestCheckoutSource, FirstAgentContext } from "@getpaseo/protocol/messages";
|
||||
import type { WorkspaceGitService } from "./workspace-git-service.js";
|
||||
import { runGitCommand, runWithGitCommandPriority } from "../utils/run-git-command.js";
|
||||
|
||||
import type { UntrustedWorkspaceSource } from "./workspace-automation-gate.js";
|
||||
|
||||
export interface CreateWorktreeCoreInput {
|
||||
cwd: string;
|
||||
worktreeSlug?: string;
|
||||
@@ -36,6 +46,10 @@ export interface CreateWorktreeCoreInput {
|
||||
|
||||
export interface CreateWorktreeCoreDeps {
|
||||
lifecycle?: Pick<PluginLifecycle, "before">;
|
||||
worktreeManagers?: Pick<
|
||||
PluginWorktreeManagerRuntime,
|
||||
"hasWorktreeManager" | "createWorktree" | "removeWorktree"
|
||||
>;
|
||||
github: ForgeService;
|
||||
workspaceGitService?: Pick<
|
||||
WorkspaceGitService,
|
||||
@@ -47,6 +61,7 @@ export interface CreateWorktreeCoreDeps {
|
||||
export interface CreateWorktreeCoreResult {
|
||||
worktree: CreatedWorktree;
|
||||
intent: WorktreeCreationIntent;
|
||||
untrustedSource?: UntrustedWorkspaceSource;
|
||||
repoRoot: string;
|
||||
created: boolean;
|
||||
}
|
||||
@@ -146,8 +161,28 @@ async function createWorktreeCoreWithPriority(
|
||||
const transformed = deps.lifecycle
|
||||
? await deps.lifecycle.before("worktree.create.before", request)
|
||||
: request;
|
||||
const originalUntrustedSource = worktreeUntrustedSource(intent);
|
||||
normalizedSlug = validateWorktreeSlug(transformed.slug);
|
||||
intent = creationIntentFromRequest(transformed, intent);
|
||||
const untrustedSource = originalUntrustedSource ?? worktreeUntrustedSource(intent);
|
||||
|
||||
const { worktree: managedWorktree, preparedBranchOff } = await tryCreateWithWorktreeManager({
|
||||
repoRoot,
|
||||
transformed,
|
||||
intent,
|
||||
untrusted: Boolean(untrustedSource),
|
||||
input,
|
||||
deps,
|
||||
});
|
||||
if (managedWorktree) {
|
||||
return {
|
||||
worktree: managedWorktree,
|
||||
intent,
|
||||
untrustedSource,
|
||||
repoRoot,
|
||||
created: true,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
worktree: await createWorktree({
|
||||
@@ -155,15 +190,51 @@ async function createWorktreeCoreWithPriority(
|
||||
worktreeSlug: normalizedSlug,
|
||||
worktreePath: transformed.path,
|
||||
source: intent,
|
||||
preparedBranchOff,
|
||||
paseoHome: input.paseoHome,
|
||||
worktreesRoot: input.worktreesRoot,
|
||||
}),
|
||||
intent,
|
||||
untrustedSource,
|
||||
repoRoot,
|
||||
created: true,
|
||||
};
|
||||
}
|
||||
|
||||
async function tryCreateWithWorktreeManager(options: {
|
||||
repoRoot: string;
|
||||
transformed: PluginWorktreeCreateRequest;
|
||||
intent: WorktreeCreationIntent;
|
||||
untrusted: boolean;
|
||||
input: Pick<CreateWorktreeCoreInput, "paseoHome" | "worktreesRoot">;
|
||||
deps: Pick<CreateWorktreeCoreDeps, "worktreeManagers">;
|
||||
}): Promise<{ worktree: CreatedWorktree | null; preparedBranchOff?: PreparedWorktreeBranchOff }> {
|
||||
const { repoRoot, transformed, intent, untrusted, input, deps } = options;
|
||||
let preparedBranchOff: PreparedWorktreeBranchOff | undefined;
|
||||
const worktree = await runPluginWorktreeManagerCheckout({
|
||||
cwd: repoRoot,
|
||||
source: intent,
|
||||
operation: "create",
|
||||
untrusted,
|
||||
paseoHome: input.paseoHome,
|
||||
worktreesBaseRoot: input.worktreesRoot,
|
||||
worktreeManagers: deps.worktreeManagers,
|
||||
run: async ({ changeRequestHeadSha }) => {
|
||||
let request: PluginWorktreeCreateInput = {
|
||||
...transformed,
|
||||
untrusted,
|
||||
...(changeRequestHeadSha ? { headSha: changeRequestHeadSha } : {}),
|
||||
};
|
||||
if (request.kind === "branch-off" && intent.kind === "branch-off") {
|
||||
preparedBranchOff = await prepareWorktreeBranchOff(repoRoot, intent);
|
||||
request = { ...request, baseRef: preparedBranchOff.baseRef };
|
||||
}
|
||||
return deps.worktreeManagers!.createWorktree(request);
|
||||
},
|
||||
});
|
||||
return { worktree, preparedBranchOff };
|
||||
}
|
||||
|
||||
function describeCreationRequest(
|
||||
intent: WorktreeCreationIntent,
|
||||
placement: Pick<PluginWorktreeCreateRequest, "repoRoot" | "sourceCheckout" | "slug" | "path">,
|
||||
@@ -174,6 +245,7 @@ function describeCreationRequest(
|
||||
kind: intent.kind,
|
||||
branch: intent.branchName,
|
||||
baseRef: intent.baseBranch,
|
||||
...(intent.startPoint ? { startPoint: intent.startPoint } : {}),
|
||||
};
|
||||
if (intent.kind === "checkout-branch")
|
||||
return { ...placement, kind: intent.kind, branch: intent.branchName };
|
||||
|
||||
@@ -78,7 +78,7 @@ export function isPathInsideRoot(root: string, candidate: string): boolean {
|
||||
}
|
||||
|
||||
export function normalizePathForIdentity(value: string): string {
|
||||
const canonicalPath = resolveRealpathVariants(value)[0] ?? value;
|
||||
const canonicalPath = resolveNearestExistingAncestorRealpath(value);
|
||||
return normalizePathForComparison(canonicalPath, looksLikeDefiniteWindowsPath(canonicalPath));
|
||||
}
|
||||
|
||||
@@ -150,6 +150,26 @@ function resolveRealpathVariants(value: string): string[] {
|
||||
return variants;
|
||||
}
|
||||
|
||||
function resolveNearestExistingAncestorRealpath(value: string): string {
|
||||
if (process.platform !== "win32" && looksLikeDefiniteWindowsPath(value)) {
|
||||
return value;
|
||||
}
|
||||
const tail: string[] = [];
|
||||
let current = value;
|
||||
while (true) {
|
||||
const resolved = resolveRealpathVariants(current)[0];
|
||||
if (resolved) {
|
||||
return tail.length === 0 ? resolved : nodePath.join(resolved, ...tail.toReversed());
|
||||
}
|
||||
const parent = nodePath.dirname(current);
|
||||
if (parent === current) {
|
||||
return value;
|
||||
}
|
||||
tail.push(nodePath.basename(current));
|
||||
current = parent;
|
||||
}
|
||||
}
|
||||
|
||||
function shouldCompareAsWindows(left: string, right: string): boolean {
|
||||
return looksLikeDefiniteWindowsPath(left) || looksLikeDefiniteWindowsPath(right);
|
||||
}
|
||||
|
||||
@@ -22,6 +22,7 @@ const PaseoWorktreeMetadataV1Schema = z.object({
|
||||
baseRefName: z.string().min(1),
|
||||
baseRef: z.string().min(1).optional(),
|
||||
changeRequestLookupTarget: ChangeRequestLookupTargetSchema.optional(),
|
||||
worktreeManagerPluginId: z.string().min(1).optional(),
|
||||
});
|
||||
|
||||
const PaseoWorktreeMetadataV2Schema = z.object({
|
||||
@@ -29,6 +30,7 @@ const PaseoWorktreeMetadataV2Schema = z.object({
|
||||
baseRefName: z.string().min(1),
|
||||
baseRef: z.string().min(1).optional(),
|
||||
changeRequestLookupTarget: ChangeRequestLookupTargetSchema.optional(),
|
||||
worktreeManagerPluginId: z.string().min(1).optional(),
|
||||
firstAgentBranchAutoName: z
|
||||
.discriminatedUnion("status", [
|
||||
z.object({
|
||||
@@ -227,6 +229,7 @@ export async function writePaseoWorktreeMetadata(
|
||||
baseRefName: string;
|
||||
baseRef?: string;
|
||||
changeRequestLookupTarget?: PaseoWorktreeChangeRequestHint;
|
||||
worktreeManagerPluginId?: string;
|
||||
},
|
||||
): Promise<void> {
|
||||
return mutateMetadata(worktreeRoot, async (root) => {
|
||||
@@ -244,6 +247,9 @@ export async function writePaseoWorktreeMetadata(
|
||||
...(options.changeRequestLookupTarget
|
||||
? { changeRequestLookupTarget: options.changeRequestLookupTarget }
|
||||
: {}),
|
||||
...(options.worktreeManagerPluginId
|
||||
? { worktreeManagerPluginId: options.worktreeManagerPluginId }
|
||||
: {}),
|
||||
};
|
||||
await writePaseoWorktreeMetadataFile(root, metadata);
|
||||
});
|
||||
|
||||
@@ -47,8 +47,10 @@ async function pathExists(path: string): Promise<boolean> {
|
||||
export async function validateWorktreePath(options: {
|
||||
candidate: string;
|
||||
repoPath: string;
|
||||
/** The worktree manager already created the destination, so it is expected to exist. */
|
||||
allowExistingPath?: boolean;
|
||||
}): Promise<string> {
|
||||
const { candidate, repoPath } = options;
|
||||
const { candidate, repoPath, allowExistingPath = false } = options;
|
||||
if (!isAbsolute(candidate)) {
|
||||
throw new Error(
|
||||
`Worktree hook returned a relative path '${candidate}'; it must be an absolute path`,
|
||||
@@ -79,7 +81,7 @@ export async function validateWorktreePath(options: {
|
||||
if (relativeToCandidate !== null && relativeToCandidate !== "") {
|
||||
throw new Error(`Worktree hook returned an ancestor of the repository: ${normalized}`);
|
||||
}
|
||||
if ((await pathExists(normalized)) || (await pathExists(candidate))) {
|
||||
if (!allowExistingPath && ((await pathExists(normalized)) || (await pathExists(candidate)))) {
|
||||
throw new Error(
|
||||
`Worktree hook returned a path that already exists: ${normalized}. Paseo creates the returned path.`,
|
||||
);
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,20 @@
|
||||
# Worktrunk plugin example
|
||||
|
||||
Delegates Paseo worktree creation, removal, and restoration to [Worktrunk](https://worktrunk.dev) (`wt`), and updates `wt list` activity markers (`🤖` / `💬`) as agents run.
|
||||
|
||||
## What it does
|
||||
|
||||
- **Create:** routes branch-off, branch checkout, and change-request (PR/MR) creation through `wt switch --no-cd --format=json` (using Paseo's fetched `headSha` for PR/MR checkouts, and `--no-hooks` on untrusted fork checkouts) so Worktrunk controls placement, branch setup, and `pre-start` / `post-start` hooks. Local branch collisions decline and fall back to Paseo's Git checkout.
|
||||
- **Remove:** routes archive and creation rollback through `wt remove --foreground --no-delete-branch --yes` so Worktrunk runs `pre-remove` and `post-remove` hooks while keeping the branch for Paseo's restore flow.
|
||||
- **Restore:** routes archived worktree restoration through `wt switch --path <recorded-path>` for branch restores, and falls back to Paseo for detached-commit restores.
|
||||
- **Activity markers:** sets `🤖` when an agent turn starts, `💬` when a turn ends or awaits permission, and clears the marker on close or archive. Background helpers are skipped.
|
||||
|
||||
## Prerequisites
|
||||
|
||||
Install Worktrunk (`wt`, or `git-wt.exe` on Windows) on `PATH`, or set `WORKTRUNK_BIN` in the daemon environment.
|
||||
|
||||
## Install
|
||||
|
||||
```bash
|
||||
paseo plugin install /absolute/path/to/plugin-examples/worktrunk
|
||||
```
|
||||
@@ -0,0 +1,44 @@
|
||||
import type { PluginServerContext } from "@getpaseo/plugin/server";
|
||||
import {
|
||||
WAITING_MARKER,
|
||||
WORKING_MARKER,
|
||||
createWithWorktrunk,
|
||||
removeWithWorktrunk,
|
||||
restoreWithWorktrunk,
|
||||
setActivityMarker,
|
||||
} from "./server/wt.js";
|
||||
|
||||
export default function contribute(server: PluginServerContext) {
|
||||
const cleanups = [
|
||||
server.registerWorktreeManager({
|
||||
create: (request, { signal }) => createWithWorktrunk(request, signal),
|
||||
remove: (request, { signal }) => removeWithWorktrunk(request, signal),
|
||||
restore: (request, { signal }) => restoreWithWorktrunk(request, signal),
|
||||
}),
|
||||
|
||||
server.addHook("agent.turn.before", async ({ agent }, { signal }) => {
|
||||
if (agent.background) return;
|
||||
await setActivityMarker(agent.cwd, WORKING_MARKER, signal);
|
||||
}),
|
||||
server.addHook("agent.turn.after", async ({ agent }, { signal }) => {
|
||||
if (agent.background) return;
|
||||
await setActivityMarker(agent.cwd, WAITING_MARKER, signal);
|
||||
}),
|
||||
server.addHook("agent.permission.before", async ({ agent }, { signal }) => {
|
||||
if (agent.background) return;
|
||||
await setActivityMarker(agent.cwd, WAITING_MARKER, signal);
|
||||
}),
|
||||
server.addHook("agent.close.after", async ({ agent }, { signal }) => {
|
||||
if (agent.background) return;
|
||||
await setActivityMarker(agent.cwd, null, signal);
|
||||
}),
|
||||
server.addHook("agent.archive.after", async ({ agent }, { signal }) => {
|
||||
if (agent.background) return;
|
||||
await setActivityMarker(agent.cwd, null, signal);
|
||||
}),
|
||||
];
|
||||
|
||||
return () => {
|
||||
for (const cleanup of cleanups) cleanup();
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"id": "worktrunk",
|
||||
"name": "Worktrunk",
|
||||
"description": "Manage Git worktrees and agent activity markers through Worktrunk (wt).",
|
||||
"requirements": { "paseo": ">=0.17.0" }
|
||||
}
|
||||
@@ -0,0 +1,317 @@
|
||||
import { lstatSync } from "node:fs";
|
||||
import { readFile, writeFile } from "node:fs/promises";
|
||||
import { delimiter, join } from "node:path";
|
||||
import {
|
||||
execCommand,
|
||||
type PluginWorktreeCreateInput,
|
||||
type PluginWorktreeRemoveRequest,
|
||||
type PluginWorktreeRestoreRequest,
|
||||
} from "@getpaseo/plugin/server";
|
||||
|
||||
const MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
|
||||
const CREATED_BRANCH_FILE = "paseo-worktrunk-created-branch";
|
||||
|
||||
export const WORKING_MARKER = "🤖";
|
||||
export const WAITING_MARKER = "💬";
|
||||
|
||||
interface SwitchJsonOutput {
|
||||
path: string;
|
||||
action?: string;
|
||||
branch?: string;
|
||||
createdBranch: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolve the Worktrunk CLI executable.
|
||||
* Honors `WORKTRUNK_BIN` first; on Windows prefers `git-wt.exe` and skips the
|
||||
* WindowsApps alias that points to Windows Terminal.
|
||||
*/
|
||||
export function resolveWorktrunkBin(): string | null {
|
||||
const configured = process.env.WORKTRUNK_BIN?.trim();
|
||||
if (configured) return configured;
|
||||
if (process.platform !== "win32") return "wt";
|
||||
|
||||
const dirs = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
|
||||
const findOnPath = (name: string) =>
|
||||
dirs
|
||||
.map((dir) => join(dir, name))
|
||||
.find((candidate) => {
|
||||
try {
|
||||
lstatSync(candidate);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
|
||||
if (findOnPath("git-wt.exe")) return "git-wt.exe";
|
||||
const wt = findOnPath("wt.exe");
|
||||
return wt && !/[\\/]WindowsApps[\\/]/i.test(wt) ? "wt" : null;
|
||||
}
|
||||
|
||||
async function runWt(
|
||||
args: string[],
|
||||
options: { cwd?: string; signal?: AbortSignal } = {},
|
||||
): Promise<string> {
|
||||
const bin = resolveWorktrunkBin();
|
||||
if (!bin) {
|
||||
throw new Error(
|
||||
"Worktrunk CLI not found on PATH. Install wt (or git-wt.exe on Windows) or set WORKTRUNK_BIN.",
|
||||
);
|
||||
}
|
||||
try {
|
||||
const { stdout } = await execCommand(bin, args, {
|
||||
cwd: options.cwd,
|
||||
signal: options.signal,
|
||||
maxBuffer: MAX_OUTPUT_BYTES,
|
||||
});
|
||||
return stdout;
|
||||
} catch (error) {
|
||||
const stderr = (error as { stderr?: string }).stderr?.trim();
|
||||
throw new Error(stderr || (error instanceof Error ? error.message : String(error)), {
|
||||
cause: error,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
function tryParseSwitchOutput(stdout: string | undefined): SwitchJsonOutput | null {
|
||||
if (!stdout?.trim()) return null;
|
||||
try {
|
||||
const parsed = JSON.parse(stdout) as {
|
||||
path?: unknown;
|
||||
action?: unknown;
|
||||
branch?: unknown;
|
||||
created_branch?: unknown;
|
||||
from_remote?: unknown;
|
||||
};
|
||||
if (typeof parsed.path !== "string" || parsed.path.length === 0) return null;
|
||||
return {
|
||||
path: parsed.path,
|
||||
// Worktrunk sets from_remote when switch creates a branch that tracks a remote.
|
||||
createdBranch:
|
||||
parsed.created_branch === true ||
|
||||
(typeof parsed.from_remote === "string" && parsed.from_remote.length > 0),
|
||||
...(typeof parsed.branch === "string" && parsed.branch ? { branch: parsed.branch } : {}),
|
||||
...(typeof parsed.action === "string" ? { action: parsed.action } : {}),
|
||||
};
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function parseSwitchOutput(stdout: string): SwitchJsonOutput {
|
||||
const parsed = tryParseSwitchOutput(stdout);
|
||||
if (!parsed) {
|
||||
throw new Error("wt switch --format=json output did not include a worktree path");
|
||||
}
|
||||
return parsed;
|
||||
}
|
||||
|
||||
function hookFlags(untrusted: boolean): string[] {
|
||||
// Never approve repository-defined hooks on untrusted checkouts such as fork PRs.
|
||||
return untrusted ? ["--no-hooks"] : ["--yes"];
|
||||
}
|
||||
|
||||
export function buildCreateArgs(request: PluginWorktreeCreateInput): string[] | null {
|
||||
const common = [
|
||||
"-C",
|
||||
request.repoRoot,
|
||||
"switch",
|
||||
"--no-cd",
|
||||
...hookFlags(request.untrusted),
|
||||
"--format=json",
|
||||
];
|
||||
switch (request.kind) {
|
||||
case "branch-off":
|
||||
return [
|
||||
...common,
|
||||
"--create",
|
||||
request.branch,
|
||||
"--base",
|
||||
request.startPoint ?? request.baseRef,
|
||||
];
|
||||
case "checkout-branch":
|
||||
return [...common, request.branch];
|
||||
case "checkout-change-request":
|
||||
case "checkout-github-pr":
|
||||
if (!request.headSha) return null;
|
||||
return [...common, "--create", request.branch, "--base", request.headSha];
|
||||
}
|
||||
}
|
||||
|
||||
function failedSwitchOutput(error: unknown): SwitchJsonOutput | null {
|
||||
// Worktrunk reports the checkout and whether it created the branch even if a hook fails.
|
||||
const stdout =
|
||||
error instanceof Error && error.cause && typeof error.cause === "object"
|
||||
? (error.cause as { stdout?: string }).stdout
|
||||
: undefined;
|
||||
return tryParseSwitchOutput(stdout);
|
||||
}
|
||||
|
||||
async function createdBranchFile(worktreePath: string): Promise<string> {
|
||||
const { stdout } = await execCommand("git", ["rev-parse", "--absolute-git-dir"], {
|
||||
cwd: worktreePath,
|
||||
});
|
||||
return join(stdout.trim(), CREATED_BRANCH_FILE);
|
||||
}
|
||||
|
||||
async function cleanupPartiallyCreatedWorktree(
|
||||
repoRoot: string,
|
||||
output: SwitchJsonOutput | null,
|
||||
): Promise<void> {
|
||||
if (output?.action !== "created") return;
|
||||
await runWt([
|
||||
"-C",
|
||||
repoRoot,
|
||||
"remove",
|
||||
"--foreground",
|
||||
"--no-delete-branch",
|
||||
"--no-hooks",
|
||||
"--force",
|
||||
output.path,
|
||||
]);
|
||||
if (output.createdBranch && output.branch) {
|
||||
await execCommand("git", ["branch", "-D", "--", output.branch], { cwd: repoRoot });
|
||||
}
|
||||
}
|
||||
|
||||
async function recordCreatedBranch(repoRoot: string, output: SwitchJsonOutput): Promise<void> {
|
||||
if (output.action !== "created" || !output.createdBranch || !output.branch) return;
|
||||
try {
|
||||
// The linked worktree owns this record until removal. An archive keeps the branch.
|
||||
await writeFile(await createdBranchFile(output.path), output.branch, { flag: "wx" });
|
||||
} catch (error) {
|
||||
await cleanupPartiallyCreatedWorktree(repoRoot, output).catch(() => {});
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
async function hasLocalBranch(
|
||||
repoRoot: string,
|
||||
branch: string,
|
||||
signal: AbortSignal,
|
||||
): Promise<boolean> {
|
||||
const ref = `refs/heads/${branch}`;
|
||||
const { stdout } = await execCommand("git", ["for-each-ref", "--format=%(refname)", ref], {
|
||||
cwd: repoRoot,
|
||||
signal,
|
||||
});
|
||||
return stdout.trim().split(/\r?\n/).includes(ref);
|
||||
}
|
||||
|
||||
export async function createWithWorktrunk(
|
||||
request: PluginWorktreeCreateInput,
|
||||
signal: AbortSignal,
|
||||
): Promise<{ type: "created"; path: string } | undefined> {
|
||||
const args = buildCreateArgs(request);
|
||||
if (!args) return undefined;
|
||||
// With a local branch collision, decline so Paseo's Git checkout allocates a unique branch
|
||||
// name without disturbing the existing local branch.
|
||||
const createsLocalBranch =
|
||||
request.kind === "branch-off" ||
|
||||
request.kind === "checkout-change-request" ||
|
||||
request.kind === "checkout-github-pr";
|
||||
if (createsLocalBranch && (await hasLocalBranch(request.repoRoot, request.branch, signal))) {
|
||||
return undefined;
|
||||
}
|
||||
let stdout: string;
|
||||
try {
|
||||
stdout = await runWt(args, { signal });
|
||||
} catch (error) {
|
||||
await cleanupPartiallyCreatedWorktree(request.repoRoot, failedSwitchOutput(error)).catch(
|
||||
() => {},
|
||||
);
|
||||
throw error;
|
||||
}
|
||||
const output = parseSwitchOutput(stdout);
|
||||
// If Worktrunk switched to an already-existing checkout instead of creating one,
|
||||
// decline so Paseo falls back to Git (which creates a unique branch).
|
||||
if (output.action !== undefined && output.action !== "created") {
|
||||
return undefined;
|
||||
}
|
||||
await recordCreatedBranch(request.repoRoot, output);
|
||||
return { type: "created", path: output.path };
|
||||
}
|
||||
|
||||
export async function removeWithWorktrunk(
|
||||
request: PluginWorktreeRemoveRequest,
|
||||
signal: AbortSignal,
|
||||
): Promise<{ type: "removed" }> {
|
||||
// Run from the main repository root when available and skip repository hooks for
|
||||
// untrusted workspaces (or when repoRoot is unknown) so fork PRs cannot run hooks.
|
||||
const runDir = request.repoRoot ?? request.path;
|
||||
const skipHooks = request.untrusted || request.repoRoot === null;
|
||||
const args = [
|
||||
"-C",
|
||||
runDir,
|
||||
"remove",
|
||||
"--foreground",
|
||||
"--no-delete-branch",
|
||||
...hookFlags(skipHooks),
|
||||
...(request.force ? ["--force"] : []),
|
||||
request.path,
|
||||
];
|
||||
const createdBranch =
|
||||
request.reason === "rollback" && request.repoRoot && request.branch
|
||||
? await createdBranchFile(request.path)
|
||||
.then((file) => readFile(file, "utf8"))
|
||||
.catch(() => null)
|
||||
: null;
|
||||
await runWt(args, { signal });
|
||||
if (createdBranch && createdBranch === request.branch && request.repoRoot) {
|
||||
await execCommand("git", ["branch", "-D", "--", createdBranch], { cwd: request.repoRoot });
|
||||
}
|
||||
return { type: "removed" };
|
||||
}
|
||||
|
||||
export async function restoreWithWorktrunk(
|
||||
request: PluginWorktreeRestoreRequest,
|
||||
signal: AbortSignal,
|
||||
): Promise<{ type: "restored"; path: string } | undefined> {
|
||||
if (request.target.type === "commit") {
|
||||
// Detached-commit restores fall back to Paseo's built-in Git restore.
|
||||
return undefined;
|
||||
}
|
||||
const common = [
|
||||
"-C",
|
||||
request.repoRoot,
|
||||
"switch",
|
||||
"--path",
|
||||
request.path,
|
||||
"--no-cd",
|
||||
...hookFlags(request.untrusted),
|
||||
"--format=json",
|
||||
];
|
||||
const args =
|
||||
request.target.type === "branch"
|
||||
? [...common, request.target.branch]
|
||||
: [...common, "--create", request.target.branch, "--base", request.target.baseRef];
|
||||
let stdout: string;
|
||||
try {
|
||||
stdout = await runWt(args, { signal });
|
||||
} catch (error) {
|
||||
await cleanupPartiallyCreatedWorktree(request.repoRoot, failedSwitchOutput(error)).catch(
|
||||
() => {},
|
||||
);
|
||||
throw error;
|
||||
}
|
||||
const output = parseSwitchOutput(stdout);
|
||||
await recordCreatedBranch(request.repoRoot, output);
|
||||
return { type: "restored", path: output.path };
|
||||
}
|
||||
|
||||
export async function setActivityMarker(
|
||||
cwd: string,
|
||||
marker: string | null,
|
||||
signal: AbortSignal,
|
||||
): Promise<void> {
|
||||
const args =
|
||||
marker === null
|
||||
? ["config", "state", "marker", "clear"]
|
||||
: ["config", "state", "marker", "set", marker];
|
||||
try {
|
||||
await runWt(args, { cwd, signal });
|
||||
} catch {
|
||||
// Activity markers are best-effort and must not disrupt agent sessions.
|
||||
}
|
||||
}
|
||||
@@ -208,7 +208,7 @@ Every field except `repoRoot` and `sourceCheckout` is transformable. Return all
|
||||
|
||||
Paseo resolves symlinked parents and validates the returned path. It must be absolute, must not exist, and must not be the filesystem root, your home directory, the repository root, inside a `.git` directory, or an ancestor of the repository. An existing destination fails creation; Paseo never adds a suffix to a plugin-chosen path. The plugin must leave directory creation to Paseo.
|
||||
|
||||
Ordering: `worktree.create.before` → `git worktree add` → `worktree.create.after` → workspace registration. Restoring a missing worktree recreates it at its recorded path without running either worktree creation hook.
|
||||
Ordering: `worktree.create.before` → worktree manager `create` (or `git worktree add`) → `worktree.create.after` → workspace registration. To delegate `git worktree add`, removal, and restoration to an external tool such as Worktrunk, register a [worktree manager](/docs/plugins/reference#worktree-managers) with `server.registerWorktreeManager()` instead of creating directories inside `worktree.create.before`. Restoring a missing worktree recreates it at its recorded path without running creation hooks, delegating to the owning manager's optional `restore` handler when present.
|
||||
|
||||
## worktree.create.after
|
||||
|
||||
@@ -700,6 +700,7 @@ replaces that scope's prior value.
|
||||
| [lifecycle-actions](https://github.com/getpaseo/paseo/tree/main/plugin-examples/lifecycle-actions) | Follow-ups, permissions, environment, provider switching, worktree selection |
|
||||
| [agent-configuration](https://github.com/getpaseo/paseo/tree/main/plugin-examples/agent-configuration) | MCP injection and Codex sandbox/approval options |
|
||||
| [agent-tools](https://github.com/getpaseo/paseo/tree/main/plugin-examples/agent-tools) | Label-targeted tools and file operations in the plugin process |
|
||||
| [worktrunk](https://github.com/getpaseo/paseo/tree/main/plugin-examples/worktrunk) | Worktree manager (`create`, `remove`, `restore`) and agent activity markers |
|
||||
|
||||
Read logger output with `paseo plugin logs lifecycle-logger` or the host's `daemon.log`.
|
||||
|
||||
|
||||
@@ -205,7 +205,7 @@ server.addHook("worktree.create.before", async ({ request }) => ({
|
||||
|
||||
Paseo 解析父目录中的符号链接并验证返回的路径。路径必须为绝对路径且不存在,不能是文件系统根目录、用户主目录、仓库根目录、`.git` 目录内的路径或仓库的祖先目录。目标已存在时创建失败,Paseo 不会为插件选择的路径添加后缀。插件应让 Paseo 创建目录。
|
||||
|
||||
顺序:`worktree.create.before` → `git worktree add` → `worktree.create.after` → 注册工作区。恢复缺失的 worktree 时使用记录的原路径,不运行这两个创建钩子。
|
||||
顺序:`worktree.create.before` → worktree 管理器 `create`(或 `git worktree add`)→ `worktree.create.after` → 注册工作区。若要将 `git worktree add`、移除和恢复委托给 Worktrunk 等外部工具,请使用 `server.registerWorktreeManager()` 注册 [worktree 管理器](/docs/plugins/reference#worktree-managers),而不是在 `worktree.create.before` 中创建目录。恢复缺失的 worktree 时使用记录的原路径,不运行创建钩子,并在对应管理器提供可选 `restore` 处理函数时委托给它。
|
||||
|
||||
## worktree.create.after {#worktreecreateafter}
|
||||
|
||||
@@ -677,12 +677,13 @@ Creation request
|
||||
|
||||
## 完整示例 {#complete-examples}
|
||||
|
||||
| 插件 | 包含 |
|
||||
| ------------------------------------------------------------------------------------------------------ | --------------------------------------------------------- |
|
||||
| [lifecycle-logger](https://github.com/getpaseo/paseo/tree/main/plugin-examples/lifecycle-logger) | Agent、工作区和 worktree 钩子;隐去环境变量值的 JSON 日志 |
|
||||
| [lifecycle-actions](https://github.com/getpaseo/paseo/tree/main/plugin-examples/lifecycle-actions) | 后续消息、权限、环境变量、切换 Provider、选择 worktree |
|
||||
| [agent-configuration](https://github.com/getpaseo/paseo/tree/main/plugin-examples/agent-configuration) | MCP 注入以及 Codex 沙盒/批准选项 |
|
||||
| [agent-tools](https://github.com/getpaseo/paseo/tree/main/plugin-examples/agent-tools) | 按标签选择 Agent,并在插件进程中执行文件操作的工具 |
|
||||
| 插件 | 包含 |
|
||||
| ------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------- |
|
||||
| [lifecycle-logger](https://github.com/getpaseo/paseo/tree/main/plugin-examples/lifecycle-logger) | Agent、工作区和 worktree 钩子;隐去环境变量值的 JSON 日志 |
|
||||
| [lifecycle-actions](https://github.com/getpaseo/paseo/tree/main/plugin-examples/lifecycle-actions) | 后续消息、权限、环境变量、切换 Provider、选择 worktree |
|
||||
| [agent-configuration](https://github.com/getpaseo/paseo/tree/main/plugin-examples/agent-configuration) | MCP 注入以及 Codex 沙盒/批准选项 |
|
||||
| [agent-tools](https://github.com/getpaseo/paseo/tree/main/plugin-examples/agent-tools) | 按标签选择 Agent,并在插件进程中执行文件操作的工具 |
|
||||
| [worktrunk](https://github.com/getpaseo/paseo/tree/main/plugin-examples/worktrunk) | worktree 管理器(`create`、`remove`、`restore`)与 Agent 活动标记 |
|
||||
|
||||
用 `paseo plugin logs lifecycle-logger` 或主机的 `daemon.log` 读取 logger 的输出。
|
||||
|
||||
|
||||
@@ -692,6 +692,109 @@ for 0.10 clients and renders problems into its `error` string.
|
||||
|
||||
The source icon is a file path with the same rules as a provider icon.
|
||||
|
||||
## Worktree managers {#worktree-managers}
|
||||
|
||||
**Requires Paseo 0.17.** Register a worktree manager from `index.server.ts` with
|
||||
`server.registerWorktreeManager()` when an external tool such as Worktrunk should own creating,
|
||||
removing, and restoring Git worktrees instead of Paseo running `git worktree add` and
|
||||
`git worktree remove` directly.
|
||||
|
||||
```ts
|
||||
import { execCommand, type PluginServerContext } from "@getpaseo/plugin/server";
|
||||
|
||||
export default function contribute(server: PluginServerContext) {
|
||||
return server.registerWorktreeManager({
|
||||
async create(request, { signal }) {
|
||||
if (request.kind !== "branch-off") return;
|
||||
const { stdout } = await execCommand(
|
||||
"wt",
|
||||
[
|
||||
"-C",
|
||||
request.repoRoot,
|
||||
"switch",
|
||||
"--create",
|
||||
request.branch,
|
||||
"--base",
|
||||
request.startPoint ?? request.baseRef,
|
||||
"--no-cd",
|
||||
request.untrusted ? "--no-hooks" : "--yes",
|
||||
"--format=json",
|
||||
],
|
||||
{ signal },
|
||||
);
|
||||
const { path } = JSON.parse(stdout) as { path: string };
|
||||
return { type: "created", path };
|
||||
},
|
||||
async remove({ repoRoot, path, force, untrusted }, { signal }) {
|
||||
const skipHooks = untrusted || repoRoot === null;
|
||||
await execCommand(
|
||||
"wt",
|
||||
[
|
||||
"-C",
|
||||
repoRoot ?? path,
|
||||
"remove",
|
||||
"--foreground",
|
||||
"--no-delete-branch",
|
||||
skipHooks ? "--no-hooks" : "--yes",
|
||||
...(force ? ["--force"] : []),
|
||||
path,
|
||||
],
|
||||
{ signal },
|
||||
);
|
||||
return { type: "removed" };
|
||||
},
|
||||
async restore({ repoRoot, path, target, untrusted }, { signal }) {
|
||||
if (target.type !== "branch") return;
|
||||
const { stdout } = await execCommand(
|
||||
"wt",
|
||||
[
|
||||
"-C",
|
||||
repoRoot,
|
||||
"switch",
|
||||
target.branch,
|
||||
"--path",
|
||||
path,
|
||||
"--no-cd",
|
||||
untrusted ? "--no-hooks" : "--yes",
|
||||
"--format=json",
|
||||
],
|
||||
{ signal },
|
||||
);
|
||||
const { path: restoredPath } = JSON.parse(stdout) as { path: string };
|
||||
return { type: "restored", path: restoredPath };
|
||||
},
|
||||
});
|
||||
}
|
||||
```
|
||||
|
||||
- **Create** runs after all `worktree.create.before` hooks and before `worktree.create.after`, with a
|
||||
120-second timeout. Return `{ type: "created", path }` to claim creation, or `undefined` to decline
|
||||
so the next manager or Paseo's built-in Git checkout runs. For branch-off, Paseo resolves
|
||||
`baseRef` and refreshes a remote-tracking starting ref before calling the manager, using the
|
||||
cached ref if the fetch fails. When `request.untrusted` is `true` (for
|
||||
example, a fork change request), skip repository-defined hooks. Paseo verifies that `path` is a
|
||||
safe, newly created Git worktree of the same repository on a named branch, then records the
|
||||
checked-out `HEAD` branch (managers may normalize or uniquely name the branch, and should create a
|
||||
new branch for `branch-off`), writes comparison-base metadata, and seeds `paseo.json`. Paseo uses the
|
||||
returned path to roll back a failed adoption or later creation step. If the callback throws or
|
||||
its signal aborts before it returns, the manager is responsible for cleaning up any worktree it
|
||||
created. First-agent branch auto-rename is skipped for manager-created worktrees.
|
||||
- **Remove** is optional and runs on workspace archive and creation rollback, after Paseo runs
|
||||
`paseo.json` teardown and saves `refs/paseo/kept-commits/<sha>` for restore. Return
|
||||
`{ type: "removed" }` after removing the directory, or `undefined` to fall back to Git. When
|
||||
`untrusted` is `true` (for example, a fork change request) or `repoRoot` is `null`, skip
|
||||
repository-defined hooks and run against `repoRoot` when available. Paseo routes removal to the
|
||||
plugin that created the worktree, falling back to Git when that plugin is disabled or uninstalled.
|
||||
- **Restore** is optional and runs when unarchiving a workspace whose worktree directory was deleted.
|
||||
It receives the recorded `path` that the recreated worktree must occupy, `target` (`branch`,
|
||||
`commit`, or `from-base`), and `untrusted`. Return `{ type: "restored", path }` or `undefined` to
|
||||
fall back to Git. Paseo verifies the checkout matches the requested branch, detached commit, or
|
||||
new branch at the requested base commit. The same cleanup rules apply as for create. When
|
||||
`restore` falls back to Git, Paseo clears the workspace's manager ownership
|
||||
so subsequent archives also use Git.
|
||||
|
||||
See the complete [worktrunk example](https://github.com/getpaseo/paseo/tree/main/plugin-examples/worktrunk).
|
||||
|
||||
## Entry point and cleanup
|
||||
|
||||
Each present entry default-exports one contribution function and returns cleanup. Client entries
|
||||
|
||||
@@ -542,6 +542,84 @@ export default function contribute(server: PluginServerContext) {
|
||||
|
||||
来源图标是一个文件路径,规则与 Provider 图标相同。
|
||||
|
||||
## worktree 管理器 {#worktree-managers}
|
||||
|
||||
**需要 Paseo 0.17**。在服务端入口 `index.server.ts` 中调用 `server.registerWorktreeManager()`,可将 Git worktree 的创建、移除和恢复委托给 Worktrunk 等外部工具,而无需由 Paseo 直接运行 `git worktree add` 和 `git worktree remove`。
|
||||
|
||||
```ts
|
||||
import { execCommand, type PluginServerContext } from "@getpaseo/plugin/server";
|
||||
|
||||
export default function contribute(server: PluginServerContext) {
|
||||
return server.registerWorktreeManager({
|
||||
async create(request, { signal }) {
|
||||
if (request.kind !== "branch-off") return;
|
||||
const { stdout } = await execCommand(
|
||||
"wt",
|
||||
[
|
||||
"-C",
|
||||
request.repoRoot,
|
||||
"switch",
|
||||
"--create",
|
||||
request.branch,
|
||||
"--base",
|
||||
request.startPoint ?? request.baseRef,
|
||||
"--no-cd",
|
||||
request.untrusted ? "--no-hooks" : "--yes",
|
||||
"--format=json",
|
||||
],
|
||||
{ signal },
|
||||
);
|
||||
const { path } = JSON.parse(stdout) as { path: string };
|
||||
return { type: "created", path };
|
||||
},
|
||||
async remove({ repoRoot, path, force, untrusted }, { signal }) {
|
||||
const skipHooks = untrusted || repoRoot === null;
|
||||
await execCommand(
|
||||
"wt",
|
||||
[
|
||||
"-C",
|
||||
repoRoot ?? path,
|
||||
"remove",
|
||||
"--foreground",
|
||||
"--no-delete-branch",
|
||||
skipHooks ? "--no-hooks" : "--yes",
|
||||
...(force ? ["--force"] : []),
|
||||
path,
|
||||
],
|
||||
{ signal },
|
||||
);
|
||||
return { type: "removed" };
|
||||
},
|
||||
async restore({ repoRoot, path, target, untrusted }, { signal }) {
|
||||
if (target.type !== "branch") return;
|
||||
const { stdout } = await execCommand(
|
||||
"wt",
|
||||
[
|
||||
"-C",
|
||||
repoRoot,
|
||||
"switch",
|
||||
target.branch,
|
||||
"--path",
|
||||
path,
|
||||
"--no-cd",
|
||||
untrusted ? "--no-hooks" : "--yes",
|
||||
"--format=json",
|
||||
],
|
||||
{ signal },
|
||||
);
|
||||
const { path: restoredPath } = JSON.parse(stdout) as { path: string };
|
||||
return { type: "restored", path: restoredPath };
|
||||
},
|
||||
});
|
||||
}
|
||||
```
|
||||
|
||||
- **Create**:在所有 `worktree.create.before` 钩子之后、`worktree.create.after` 之前运行,超时为 120 秒。返回 `{ type: "created", path }` 表示接管创建,返回 `undefined` 表示放弃并交由下一个管理器或 Paseo 内置 Git 检出处理。创建新分支时,Paseo 会在调用管理器前解析 `baseRef`,并刷新用作起点的远程跟踪引用。如果获取失败,则使用本地缓存的引用。当 `request.untrusted` 为 `true`(例如来自 fork 变更请求)时,请跳过仓库内定义的钩子。Paseo 会验证 `path` 是同一仓库下新建且安全的命名分支 Git worktree,并记录实际检出的 `HEAD` 分支(管理器可自行规范或生成唯一分支名,但在 `branch-off` 时应创建新分支),随后写入基准元数据并生成 `paseo.json`。如果采纳或后续创建步骤失败,Paseo 会根据返回的路径回滚。回调在返回前抛出错误或收到中止信号时,由管理器清理自己创建的 worktree。由管理器创建的 worktree 会跳过首个 Agent 的分支自动重命名。
|
||||
- **Remove**:可选。在工作区归档和创建回滚时运行,位于 Paseo 执行 `paseo.json` 清理并保存 `refs/paseo/kept-commits/<sha>` 之后。删除目录后返回 `{ type: "removed" }`,或返回 `undefined` 回退到 Git。当 `untrusted` 为 `true`(例如来自 fork 变更请求)或 `repoRoot` 为 `null` 时,请跳过仓库内定义的钩子,并在可用时从 `repoRoot` 运行。Paseo 会将移除路由到创建该 worktree 的插件;若该插件已停用或移除,则回退到内置 Git。
|
||||
- **Restore**:可选。在取消归档且 worktree 目录已被删除时运行,接收必须恢复到的原路径 `path`、目标 `target`(`branch`、`commit` 或 `from-base`)以及 `untrusted`。返回 `{ type: "restored", path }`,或返回 `undefined` 回退到 Git。Paseo 会验证检出结果是否为指定的分支、分离 HEAD 的提交,或位于指定基准提交的新分支。清理规则与 Create 相同。当 `restore` 回退到 Git 时,Paseo 会清除该工作区的管理器归属,后续归档也会使用 Git。
|
||||
|
||||
完整插件见 [worktrunk 示例](https://github.com/getpaseo/paseo/tree/main/plugin-examples/worktrunk)。
|
||||
|
||||
## 入口与清理 {#entry-point-and-cleanup}
|
||||
|
||||
每个存在的入口都默认导出一个贡献函数,并返回清理函数。客户端入口接收 `PluginClientContext`;服务端入口接收 `PluginServerContext`。客户端注册方法返回幂等的移除函数,但标题栏按钮和 Composer 标签除外,它们返回 `{ update, remove }` 句柄。入口的清理函数会在 Paseo 移除剩余的注册之前运行。
|
||||
|
||||
Reference in New Issue
Block a user