Compare commits

..
Author SHA1 Message Date
Mohamed Boudra d154df3165 Let plugins manage worktree creation, removal, and restoration (#10278)
* feat(plugins): let plugins manage worktree create, remove, and restore

Adds server.registerWorktreeManager({ create, remove?, restore? }) so external worktree tools such as Worktrunk can own Git worktree creation, removal, and restoration instead of overloading worktree.create.before.

Keeping worktree.create.before purely transformative preserves multi-plugin chaining, rollback, and the 30s hook budget, while giving manager operations a 120s budget matching git worktree commands. Paseo snapshots existing worktrees before create so managers cannot hijack pre-existing user worktrees, writes comparison-base and owning plugin metadata into paseo/worktree.json and the workspace record, saves refs/paseo/kept-commits before removal so restore stays safe, and falls back to built-in Git if a manager declines or is disabled.

* fix(plugins): harden worktree manager lifecycle, rollback, and schema

* fix(plugins): pass untrusted on create, clean up rejected worktrees, and sync docs

* refactor(plugins): unify worktree manager checkout flow and metadata rules

* fix(plugins): verify managed worktree ownership and restore targets

A failed callback does not establish ownership of worktrees created during its call. Require the manager to identify the checkout before Paseo attempts rollback, and verify the requested Git target before reopening a restored workspace.

* fix(plugins): preserve worktree setup on retry and refresh branch bases

A failed setup could leave a new branch behind and send the retry through the built-in checkout. Use the manager's reported branch creation status during rollback. Share base preparation so both checkout paths start from the updated remote-tracking ref.

* fix(plugins): preserve managed checkout targets and rollback

Keep branch creation ownership with the linked checkout so a failed after-hook can be retried with the same branch. Leave same-repository change requests with a local branch collision to the checkout path that fetches the change request head. Use the worktree timeout for compatibility commands.

* fix(worktrees): carry source trust and await managed creation

Preserve fork provenance for manager callbacks and the workspace record. Honor tracking branch creation in the manager example and let the CLI wait on the existing workspace creation lifecycle.

* fix(plugins): verify PR head commits, restore CLI worktree RPC, and fix Windows rollback paths

* fix(plugins): pre-resolve PR head, use NUL worktree snapshots, and wait on CLI worktree create

* fix(plugins): unify worktree list reader with Git 2.35 fallback and fetch PR head once

* fix(plugins): require exact worktree snapshot for managers and configure PR push remotes on adoption

* fix(server): coordinate workspace restores across daemon sessions

* fix(server): coordinate archive, undo, and restore across daemon checkout boundary

* fix: serialize open-project with checkout archive, sync sibling owners, lift client timeouts, bump plugin version

* fix: forbid nested secondary worktrees, preserve nested checkouts on archive, wait on openProject

* fix(server): refuse deleting a worktree containing a live nested Git worktree

* test(server): normalize Windows paths and teardown command in worktree-manager E2E

* fix(server): guard cross-repo nested checkouts on delete and share checkout trust across sibling workspaces

* fix(worktrees): scope nested checkout protection to managed worktrees

The removal scan treated dependency clones and recursive submodules as independent worktrees. Identify linked worktrees through Git metadata and use the scan only for manager-owned removals.

* test(worktrees): accept native line endings in archive fixtures

The nested submodule fixture checks that Git populated the checkout. The README line endings depend on the runner's Git configuration.

* docs(plugins): document the example manager Git requirement

* fix(worktrees): name the manager that returns an invalid path

The destination validator serves both creation hooks and managers. Keep its errors about the path so the caller can identify the plugin and operation.
2026-11-21 13:51:28 +07:00
paseo-bot[bot] 0a3fed0643 test(server): wait for file observation before atomic replacement (#10372)
Co-authored-by: paseo-bot[bot] <266920839+paseo-bot[bot]@users.noreply.github.com>
2026-11-21 06:45:56 +00:00
Mohamed Boudra fd2f885afd Restore a host's workspaces when its cached directory is evicted (#10318)
* fix(app): restore a host's workspaces after its cached directory is evicted

A host could keep a current directory checkpoint in the replica cache with
none of the rows it described. The daemon then answered "no changes" since
that cursor, and the sidebar had no projects to place cached workspaces
under, so every workspace for that host vanished and stayed missing across
restarts.

The cache already refused mutations for an evicted host, but it checked at
the moment a mutation was queued. Eviction happens later, inside the
serialized write, so anything queued before the eviction ran was still
written, checkpoint included. The check moves into materializePendingChanges
so it runs in the same serialized step that evicts, which also covers an
eviction that lands while an earlier persist is still indexing the store.

Checking at queue time was also losing good data: once a host was
invalidated, every mutation was dropped, including updates accepted between
a reconnect's baseline replacement and its write. Those are kept now,
because the baseline is in the same pending batch.

Version 1 checkpoints could have been written by that path, so they are no
longer trusted. A reader discards them and keeps the cached rows, so the
sidebar still paints from cache and each host re-syncs its directory once.
Later launches resume incrementally.

Both the race and the recovery live in the shared cache, so this covers iOS,
Android, web, and Electron. It does not address two tabs or windows sharing
one IndexedDB database, where another connection evicts the host.

* fix(app): hold workspace updates that arrive while the directory cache loads

A project update received while the cached directory was being read went
straight into the replica. It advanced the project cursor before any refresh
had established a baseline, and saved that cursor to the cache. On an install
damaged before the eviction fix, that write replaced the version 1 checkpoint
with a version 2 one before the reader could reject it. The refresh then asked
for project changes after the live update, the daemon had none, and projects
missing from the cache stayed missing across restarts.

Agents already open a transaction before the cache load, so their updates are
recorded and applied over the refreshed snapshot. Workspaces now do the same.
An update during the load also stops the cached cursors being adopted, so the
refresh fetches full snapshots, which is the recovery a damaged cache needs.

* fix(app): advance directory cursors from live updates only after a refresh

A live update moved the directory cursor whenever no refresh was in flight,
including when no refresh had ever completed on the current subscriptions.
If the first sync after discarding a version 1 checkpoint failed, the next
project update saved a cursor at its own sequence with only that project
stored. The retry asked for changes after it, the daemon had none, and the
other projects stayed missing across restarts. The previous commit closed
this window during the cache load only; a failed refresh reopened it.

A live event's sequence covers everything before it only when a refresh
completed on the subscriptions that delivered it, which is what
satisfiedDemandSource already records. Live events now update rows either
way but move the cursor only in that state, so a cursor never skips changes
the client did not receive. Once a refresh completes, live updates advance
the cursor as before.

The sidebar recovery e2e fixture unwrapped the checkpoint only when it was
version 1, so the version 2 writer made it abort before damaging the cache.
It now reads either envelope and stores the damage as version 1, the format
this branch stops trusting, so the test fails against the previous cache
module and passes here.

* fix(app): apply the eviction rule to malformed-row repairs

Repairing a malformed directory row reads the checkpoint, drops the affected
cursor, and writes the rest back. That write went straight to the row store
through queueOperation, outside the eviction check in the regular persist
path. If a write evicted the same host while the repair was reading, the
repair stored a checkpoint for a host with no directory rows, the state this
branch exists to prevent.

All three repair writes now go through one helper that runs in the serialized
writer and drops the checkpoint upsert when the host has been evicted since.
The deletes still apply.

* fix(app): record a host eviction only after its delete commits

Eviction marked the host as evicted before deleteHost ran. If storage aborted
that delete, the rows stayed stored but the mark remained. A malformed-row
repair running behind it trusted the mark: it skipped the checkpoint update
yet still deleted the row, leaving a workspace cursor with no workspace. The
next refresh then resumed past that workspace.

The mark is now set after the delete commits, so it always matches storage.
A failed eviction leaves no mark, and the repair updates the row and its
cursor together.
2026-11-21 13:31:29 +07:00
Mohamed Boudra 988cf4bec8 fix(acp): keep Antigravity turn open while non-daemon background tools run (#10310)
* fix(acp): keep Antigravity turn open while non-daemon background tools run

* fix(acp): address deferred turn steer, drain race, and echo scoping

* fix(acp): serialize deferred steers, gate on end_turn, and lock canceled tool updates

* fix(acp): unify deferred reply settlement and accept queued steers on send

* fix(acp): keep Stop unblocked during queued steers and gate reply settlement on post-tool updates

* fix(acp): ignore in-flight steer usage for settlement and deliver queued steers after RPC errors

* fix(acp): keep deferred background job running when a steer rejects and honor Stop cancellation

* fix(acp): settle deferred turn immediately on Stop even if a steer RPC is unanswered

* fix(acp): bound Stop drain for in-flight steers and tear down wedged runtimes

* fix(acp): terminate wedged child process on Stop timeout and reject prompts on closed sessions

* fix(acp): reject replacement prompt if session retires during interrupt and preserve streaming reply id

* fix(acp): always retire deferred ACP session cleanly on Stop and clear fallback id on steer start

* fix(server): reopen retired plugin sessions before applying configuration changes

* fix(acp): close deferred process before emitting cancel and synchronize mid-shutdown config changes

* fix(acp): do not reset deferred settle timer on excluded daemon tool updates

* fix(acp): release deferred turn when tool is reclassified as excluded

* fix(acp): gate deferred settlement reset on open qualifying tool membership

* fix(acp): decouple deferred reply tracking from open tool blockers

* fix(acp): track post-end_turn wire order and preserve settled reply across tool completion

* fix(acp): unify wire-order prompt response tracking and exclude daemon reclassification from crossedEndTurn

* fix(acp): preserve settled background reply across steers that start no new tools

* fix(acp): distinguish settled-with-open-tools reply state across steers

* fix(acp): share close and deferred interrupt retirement across overlapping calls

* fix(acp): make deferred retirement sole owner of prompt rejection and cancellation

* fix(acp): centralize session retirement in retireSession so rejected prompts never suppress session.closed

* fix(acp): bound session/cancel write in deferred retirement before teardown

* fix(acp,server): force-abort stalled connectors on Stop timeout and bound cancel wait in AgentManager

* fix(acp,server): enforce shutdown deadline on connector close and bound settings wait on queued Stop

* fix(acp): scope connector shutdown deadline to deferred retirement and finalize on late close
2026-11-21 13:27:45 +07:00
Mohamed Boudra a6a9d0b8c7 Keep agent timelines responsive after reconnect (#10368)
* fix(app): recover agent timelines after reconnect

Reconnecting resumed every hidden chat as soon as the visible chat settled, overwhelming the daemon when many tabs were open. Bound hidden catch-ups and give the visible chat priority. Refocusing a failed chat or foregrounding the app retries the timed-out fetch once per transition.

* fix(app): retain timeline retry paging policy

Carry the overflow policy with a failed request so retrying reconnect does not replay the entire backlog. Clear a failed attempt's parked follow-up so the scheduler can drain explicit retries without using the manual Retry indicator.

* fix(app): preserve history when a queued gap resumes

Choose the paging policy after a queued gap acquires its fetch slot. The tail that held the gap can establish coverage while it waits, so basing the policy on earlier coverage can unnecessarily replace history.
2026-11-21 13:26:44 +07:00
Mohamed Boudra b71b4d584a Keep live images responsive during history replay (#10371)
* perf(server): keep live image output responsive during history replay

A large attachment blocked all other provider images behind a daemon-wide queue. Share writes only for matching files and reduce the filesystem and decode turns needed to publish each image.

* fix(server): validate image storage and share the decode budget

Validate the cached directory before reusing an attachment and set file permissions without reading the process umask. A shared deadline bounds the work of concurrent decoders in each event-loop slice.

* perf(server): charge image decode slices for active work

Filesystem waits and unrelated event-loop work exhausted the wall-clock deadline before decoding started. Measure synchronous decode work against the shared budget so busy replay avoids extra yields.
2026-11-21 13:26:39 +07:00
Mohamed Boudra c9a7d523f8 Speed up Claude history reload under daemon load (#10369)
* fix(server): speed up Claude history resume under load

Each record read gave other daemon work another event-loop turn before history could finish rebuilding. Read transcript windows and resolve workflow links in one scan so resume preserves the full conversation with far fewer I/O waits.

* test(server): cover Claude replay across read windows

* fix(server): yield during dense Claude history replay

A read window of short records can keep transcript parsing and timeline ingest on the microtask queue for hundreds of milliseconds. Yield on elapsed time within each window so the daemon can service other requests.
2026-11-21 13:26:35 +07:00
Mohamed Boudra ca514b34a7 Keep Android composer buttons working on the first tap (#10308)
* fix(app): keep mobile composer buttons working on the first tap

After an unmatched native touch start (such as dismissing an Android Modal while a finger is down, double ACTION_DOWN in ReactRootView/ReactModalHostView, or a dropped synthetic ACTION_CANCEL), ReactFabric's ResponderEventPlugin left trackedTouchCount > 0 for the rest of the session because it only incremented/decremented by 1 instead of reconciling with nativeEvent.touches.length.

On Android, @mattermost/react-native-paste-input's PasteTextInput also set onSelectionChangeShouldSetResponder={emptyFunctionThatReturnsTrue} (which React Native core only sets on iOS). Whenever trackedTouchCount stayed > 0, every keystroke in the composer triggered topSelectionChange and let PasteTextInput claim the JS responder, swallowing the first tap on Send or any toolbar button.

Reconcile trackedTouchCount from nativeEvent.touches.length in ReactFabric (dev, prod, profiling) and ReactNativeResponder, remove the iOS-only onSelectionChangeShouldSetResponder prop from Android PasteTextInput, and drop the now-redundant createReactCancelEvent multi-pointer workaround from react-native-gesture-handler.

* fix(app): clear stale touchBank contacts when native touches reach zero

When a multi-touch gesture is cancelled by a single-pointer synthetic ACTION_CANCEL (or a prior touch end was dropped), ResponderTouchHistoryStore.recordTouchTrack only ended contacts listed in changedTouches, leaving other touchBank entries marked touchActive = true even though nativeEvent.touches.length was 0.

Mark all remaining active touchBank entries inactive whenever topTouchEnd or topTouchCancel reports 0 active native touches, so onResponderTerminate sees a clean touchHistory without needing RNGH's createReactCancelEvent workaround.
2026-11-21 13:20:02 +07:00
81 changed files with 12466 additions and 1187 deletions
+7 -2
View File
@@ -582,12 +582,17 @@ host, kinds, and ids. Opening a cached workspace uses exact workspace and projec
directory scan. One invalid row is deleted and returned as a miss without affecting other rows.
An invalid directory row and its affected checkpoint cursor are repaired in one transaction, so a
later launch cannot accept a checkpoint for a partial baseline. Directory changes and their
checkpoint are also applied in one transaction. Reads wait for accepted changes to reach storage,
checkpoint are also applied in one transaction. A stored checkpoint carries a version. When a writer
bug could have stored a checkpoint without its directory, bump the version: older checkpoints are
rejected on read, cached rows still paint, and each host re-syncs its directory once. Reads wait for
accepted changes to reach storage,
then retry only when a requested row changes during the read. Unrelated agent streams do not
invalidate the read. Directory baseline replacements and host removal or renaming still invalidate
the affected reads.
The cache is capped at 32 MiB and evicts whole hosts in least-recently-written order. Budget
The cache is capped at 32 MiB and evicts whole hosts in least-recently-written order. After an
eviction, only a baseline replacement stores that host's directory again. Mutations queued around
the eviction are dropped when they are written, so a checkpoint never outlives its rows. Budget
bookkeeping may scan opaque row sizes during a deferred write, never during host registry startup or
before a requested cache row can paint. The row store is not encrypted. A cached timeline can contain
source code, prompts, and tool output; encrypted-at-rest storage is a separate security decision.
+12
View File
@@ -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.
@@ -206,13 +206,14 @@ async function simulateDamagedLegacyDirectoryCache(
return;
}
const stored = JSON.parse(checkpoint.payload);
// Accept either writer so this fixture also reproduces on the unfixed client.
const cursors = stored.version === 1 ? stored.cursors : stored;
if (!cursors.workspaces?.generation) {
// Read the cursors from whichever version wrote them, then store them as version 1:
// the format whose writer could keep a checkpoint after evicting the rows it describes.
const cursors = typeof stored.version === "number" ? stored.cursors : stored;
if (!cursors?.workspaces?.generation) {
transaction.abort();
return;
}
store.put({ ...checkpoint, payload: JSON.stringify(cursors) });
store.put({ ...checkpoint, payload: JSON.stringify({ version: 1, cursors }) });
for (const row of rows) {
if (
row.serverId === serverId &&
+1 -1
View File
@@ -40,7 +40,7 @@
"dev:ios": "npm --prefix ../.. run build:client && cross-env APP_VARIANT=development expo run:ios",
"build:apk": "npm --prefix ../.. run build:apk",
"build:apk:arm64": "npm --prefix ../.. run build:apk:arm64",
"test:android": "expo prebuild --platform android --no-install && cd android && ./gradlew :paseo-native-trace:testReleaseUnitTest :paseo-hardware-keyboard:testReleaseUnitTest :react-native-enriched-markdown:testReleaseUnitTest --tests '*InlineCodeFormattingTest' --tests '*ListBlockquoteMeasurementTest' --no-daemon --max-workers=2 -Dorg.gradle.parallel=false"
"test:android": "expo prebuild --platform android --no-install && cd android && ./gradlew :paseo-native-trace:testReleaseUnitTest :paseo-hardware-keyboard:testReleaseUnitTest :react-native-enriched-markdown:testReleaseUnitTest --tests '*InlineCodeFormattingTest' --no-daemon --max-workers=2 -Dorg.gradle.parallel=false"
},
"dependencies": {
"@codemirror/commands": "6.10.4",
@@ -10,7 +10,10 @@ import type {
DaemonClient,
WorkspaceLabelListPayload,
} from "@getpaseo/client/internal/daemon-client";
import type { SessionOutboundMessage } from "@getpaseo/protocol/messages";
import type {
SessionOutboundMessage,
WorkspaceDescriptorPayload,
} from "@getpaseo/protocol/messages";
import {
normalizeProjectDescriptor,
normalizeWorkspaceDescriptor,
@@ -1667,6 +1670,187 @@ it("fills every cached workspace beneath live updates received during the SQLite
database.close();
});
/**
* A host whose cache was damaged before the eviction fix: workspaces survived, project rows did not,
* and a version 1 checkpoint still claims the project directory is current. The daemon holds
* projects A and B; renaming A is its update at `renameSeq`.
*/
async function createDamagedLegacyProjectDirectory(serverId: string, renameSeq: number) {
serverIds.add(serverId);
const { cache, database, storage, reopen, holdRead } = createSqliteCache();
cache.setHosts([serverId]);
const workspacePayload = (id: string, projectId: string): WorkspaceDescriptorPayload => ({
id,
projectId,
projectDisplayName: projectId,
projectRootPath: `/repo/${projectId}`,
workspaceDirectory: `/repo/${projectId}`,
projectKind: "git",
workspaceKind: "local_checkout",
name: id,
status: "done",
statusEnteredAt: null,
activityAt: null,
archivingAt: null,
diffStat: null,
scripts: [],
});
const project = (projectId: string, projectDisplayName: string) => ({
projectId,
projectDisplayName,
projectRootPath: `/repo/${projectId}`,
projectKind: "git" as const,
});
const workspaceEntries = [workspacePayload("wa", "A"), workspacePayload("wb", "B")];
cache.replaceDirectoryBaseline(serverId, {
agents: new Map(),
workspaces: new Map(
workspaceEntries.map((entry) => [entry.id, normalizeWorkspaceDescriptor(entry)]),
),
projects: new Map(),
});
await cache.flush();
await storage.apply({
deletes: [],
upserts: [
{
serverId,
kind: "checkpoint",
id: "singleton",
payload: JSON.stringify({
version: 1,
cursors: { projects: { generation: "g", afterSeq: renameSeq - 1 } },
}),
},
],
});
const reopened = reopen();
reopened.setHosts([serverId]);
const client = new FakeDirectoryClient();
let failNextProjectRequest = false;
client.listProjects = async (options?: unknown): Promise<ProjectListResult> => {
client.lastProjectOptions = options;
if (failNextProjectRequest) {
failNextProjectRequest = false;
throw new Error("Request timed out");
}
const resumesAfterRename =
(options as { sync?: { afterSeq?: number } } | undefined)?.sync?.afterSeq === renameSeq;
return resumesAfterRename
? {
requestId: "projects",
projects: [],
sync: { generation: "g", headSeq: renameSeq, mode: "changes", removals: [] },
}
: {
requestId: "projects",
projects: [project("A", "Renamed"), project("B", "B")],
sync: { generation: "g", headSeq: renameSeq, mode: "snapshot", removals: [] },
};
};
client.fetchWorkspaces = async (): Promise<WorkspaceFetchResult> => ({
requestId: "workspaces",
entries: workspaceEntries,
emptyProjects: [],
pageInfo: { hasMore: false, nextCursor: null, prevCursor: null },
sync: { generation: "g", headSeq: 2, mode: "snapshot", removals: [] },
});
const directory = new DirectorySync(
serverId,
{
onAgentStoppedRunning: () => {},
markAgentLoading: () => {},
markAgentReady: () => {},
markAgentError: () => {},
},
reopened,
);
const store = useSessionStore.getState();
store.initializeSession(serverId, client as unknown as DaemonClient, 1);
store.updateSessionServerInfo(serverId, {
serverId,
hostname: null,
version: "test",
features: { workspaceMultiplicity: true, directorySync: true, projectList: true },
});
directory.connectionChanged({
client: client as unknown as DaemonClient,
status: "online",
source: { clientGeneration: 1, connectionEpoch: 1 },
});
return {
client,
directory,
holdRead,
failNextProjectRequest: () => {
failNextProjectRequest = true;
},
renameProjectA: () =>
client.emit({
type: "project.update",
payload: {
kind: "upsert",
project: project("A", "Renamed"),
generation: "g",
seq: renameSeq,
},
}),
sessionProjectIds: () =>
[...useSessionStore.getState().sessions[serverId].projects.keys()].sort(),
persistedProjectIds: async () => {
await reopened.flush();
const restarted = reopen();
restarted.setHosts([serverId]);
return [...(await restarted.readDirectory(serverId)).projects.keys()].sort();
},
close: async () => {
directory.dispose();
await reopened.flush();
database.close();
},
};
}
it("re-syncs every project when a project update lands while an untrusted cache loads", async () => {
const damaged = await createDamagedLegacyProjectDirectory("untrusted-checkpoint-race", 6);
try {
let renamed = false;
damaged.holdRead(async () => {
if (renamed) return;
renamed = true;
damaged.renameProjectA();
});
damaged.directory.setDemand({}, true);
await damaged.directory.refreshDemand();
expect(renamed).toBe(true);
expect(damaged.client.lastProjectOptions).toEqual({ sync: {} });
expect(damaged.sessionProjectIds()).toEqual(["A", "B"]);
expect(await damaged.persistedProjectIds()).toEqual(["A", "B"]);
} finally {
await damaged.close();
}
});
it("re-syncs every project when a project update lands after the first sync fails", async () => {
const damaged = await createDamagedLegacyProjectDirectory("failed-first-sync", 3);
try {
damaged.failNextProjectRequest();
damaged.directory.setDemand({}, true);
await expect(damaged.directory.refreshDemand()).rejects.toThrow("Request timed out");
damaged.renameProjectA();
await damaged.directory.refreshDemand();
expect(damaged.client.lastProjectOptions).toEqual({ sync: {} });
expect(damaged.sessionProjectIds()).toEqual(["A", "B"]);
expect(await damaged.persistedProjectIds()).toEqual(["A", "B"]);
} finally {
await damaged.close();
}
});
function createWorkspaceLabelDirectory(serverId: string) {
const { client, directory } = createDirectory(serverId, { workspaceLabels: true });
const store = useSessionStore.getState();
@@ -288,7 +288,7 @@ export class DirectorySync {
this.revision += 1;
if (this.agentTransactions.record(source, delta)) return;
this.agents.applyDelta(delta);
this.noteLiveCursor("agents", delta);
if (this.extendsRefreshedBaseline(source)) this.noteLiveCursor("agents", delta);
this.persistCheckpoint();
}
@@ -300,7 +300,7 @@ export class DirectorySync {
this.workspaceRevision += 1;
if (this.workspaceTransactions.record(source, delta)) return;
this.applyWorkspaceDelta(delta);
if (delta.kind !== "script_status")
if (delta.kind !== "script_status" && this.extendsRefreshedBaseline(source))
this.noteLiveCursor(
"projectId" in delta || "project" in delta ? "projects" : "workspaces",
delta,
@@ -308,6 +308,20 @@ export class DirectorySync {
this.persistCheckpoint();
}
/**
* A live event's sequence covers everything before it only when a refresh completed on the
* subscriptions that delivered it. Before that (first sync still pending or failed) or after
* they lapse, the client may have missed earlier changes, so the event updates rows but leaves
* the cursor where the next refresh can still fetch what was missed.
*/
private extendsRefreshedBaseline(source: DirectorySourceToken): boolean {
const refreshed = this.satisfiedDemandSource;
return (
refreshed?.clientGeneration === source.clientGeneration &&
refreshed.connectionEpoch === source.connectionEpoch
);
}
private observeDirectoryEvents(): void {
if (this.eventSubscription) return;
const { client, source } = this.requireOnline();
@@ -566,24 +580,16 @@ export class DirectorySync {
input: { subscribe?: boolean } | undefined,
loadDirectoryCache: boolean,
): Promise<void> {
if (loadDirectoryCache) await this.loadCachedDirectory();
if (loadDirectoryCache) {
this.primeWorkspaceTransactionForCacheLoad();
await this.loadCachedDirectory();
}
const onlineConnection = this.getOnlineConnection();
if (!onlineConnection) return;
const { client, source } = onlineConnection;
const transaction = this.workspaceTransactions.begin(source, () => {
const baseline = this.workspaces.snapshot();
return {
workspaces: new Map(baseline.workspaces),
projects: new Map(baseline.projects),
// Cache hydration can advance the live replica while these requests await responses.
// Every page must use the cursors belonging to the maps captured here.
requestCursors: { ...this.cursors },
syncCursors: {},
syncModes: {},
touchedWorkspaceIds: new Set(),
touchedProjectIds: new Set(),
};
});
const transaction = this.workspaceTransactions.begin(source, () =>
this.createWorkspaceRefreshSnapshot(),
);
try {
await this.waitForSessionMetadata(client, source);
const serverInfo = useSessionStore.getState().sessions[this.serverId]?.serverInfo;
@@ -807,6 +813,31 @@ export class DirectorySync {
}));
}
// Updates that arrive before a refresh completes have no trusted baseline to advance from.
// Holding them keeps their cursor out of the cache until the refresh they are applied over.
private primeWorkspaceTransactionForCacheLoad(): void {
const connection = this.getOnlineConnection();
if (!connection) return;
this.workspaceTransactions.begin(connection.source, () =>
this.createWorkspaceRefreshSnapshot(),
);
}
private createWorkspaceRefreshSnapshot(): WorkspaceRefreshSnapshot {
const baseline = this.workspaces.snapshot();
return {
workspaces: new Map(baseline.workspaces),
projects: new Map(baseline.projects),
// Cache hydration can advance the live replica while these requests await responses.
// Every page must use the cursors belonging to the maps captured here.
requestCursors: { ...this.cursors },
syncCursors: {},
syncModes: {},
touchedWorkspaceIds: new Set(),
touchedProjectIds: new Set(),
};
}
private supportsDirectorySync(): boolean {
return (
useSessionStore.getState().sessions[this.serverId]?.serverInfo?.features?.directorySync ===
@@ -37,6 +37,9 @@ class MemoryStorage implements ReplicaRowStore {
onRead: (() => void) | null = null;
/** Throws once a read goes past this count, so a non-terminating read loop fails the test. */
readLimit: number | null = null;
/** Awaited before the store lists every row or deletes a host, so a test can interleave there. */
beforeReadAll: (() => Promise<void>) | null = null;
beforeDeleteHost: (() => Promise<void>) | null = null;
private key(row: Pick<ReplicaRow, "serverId" | "kind" | "id">): string {
return `${row.serverId}:${row.kind}:${row.id}`;
@@ -68,6 +71,7 @@ class MemoryStorage implements ReplicaRowStore {
}
async readAll(): Promise<ReplicaHostRows[]> {
await this.beforeReadAll?.();
const hosts = new Map<string, ReplicaRow[]>();
for (const row of this.rows.values()) {
const rows = hosts.get(row.serverId) ?? [];
@@ -91,6 +95,7 @@ class MemoryStorage implements ReplicaRowStore {
}
async deleteHost(serverId: string): Promise<void> {
await this.beforeDeleteHost?.();
for (const [key, row] of this.rows) if (row.serverId === serverId) this.rows.delete(key);
}
@@ -436,40 +441,49 @@ describe("ReplicaCache", () => {
await expectLegacyWorkspaceRefresh(cached);
});
it("rejects pre-baseline-fix checkpoints without discarding cached rows or timelines", async () => {
const storage = new MemoryStorage();
const writer = createCache(storage);
const baseline = directory();
writer.replaceDirectoryBaseline(SERVER_ID, baseline);
writer.commitTimeline(SERVER_ID, "agent-1", timeline());
await writer.flush();
await storage.apply({
deletes: [],
upserts: [
{
serverId: SERVER_ID,
kind: "checkpoint",
id: "singleton",
payload: JSON.stringify(baseline.checkpoint),
},
],
});
it.each([
["before the baseline fix", (checkpoint: DirectoryCheckpoint): unknown => checkpoint],
[
"before the eviction fix",
(checkpoint: DirectoryCheckpoint): unknown => ({ version: 1, cursors: checkpoint }),
],
])(
"rejects checkpoints written %s without discarding cached rows or timelines",
async (_era, legacyPayload) => {
const storage = new MemoryStorage();
const writer = createCache(storage);
const baseline = directory();
writer.replaceDirectoryBaseline(SERVER_ID, baseline);
writer.commitTimeline(SERVER_ID, "agent-1", timeline());
await writer.flush();
await storage.apply({
deletes: [],
upserts: [
{
serverId: SERVER_ID,
kind: "checkpoint",
id: "singleton",
payload: JSON.stringify(legacyPayload(baseline.checkpoint)),
},
],
});
const reader = createCache(storage);
const restored = await reader.readDirectory(SERVER_ID);
expect(restored.checkpoint).toBeUndefined();
expect([...restored.workspaces.keys()]).toEqual([...baseline.workspaces.keys()]);
expect([...restored.projects.keys()]).toEqual([...baseline.projects.keys()]);
expect([...restored.agents.keys()]).toEqual([...baseline.agents.keys()]);
expect(await reader.readTimeline(SERVER_ID, "agent-1")).toEqual(timeline());
expect(await storage.read(SERVER_ID, ["checkpoint"])).toEqual([]);
const reader = createCache(storage);
const restored = await reader.readDirectory(SERVER_ID);
expect(restored.checkpoint).toBeUndefined();
expect([...restored.workspaces.keys()]).toEqual([...baseline.workspaces.keys()]);
expect([...restored.projects.keys()]).toEqual([...baseline.projects.keys()]);
expect([...restored.agents.keys()]).toEqual([...baseline.agents.keys()]);
expect(await reader.readTimeline(SERVER_ID, "agent-1")).toEqual(timeline());
expect(await storage.read(SERVER_ID, ["checkpoint"])).toEqual([]);
reader.replaceDirectoryBaseline(SERVER_ID, baseline);
await reader.flush();
expect((await createCache(storage).readDirectory(SERVER_ID)).checkpoint).toEqual(
baseline.checkpoint,
);
});
reader.replaceDirectoryBaseline(SERVER_ID, baseline);
await reader.flush();
expect((await createCache(storage).readDirectory(SERVER_ID)).checkpoint).toEqual(
baseline.checkpoint,
);
},
);
it("does nothing until an owner explicitly commits data", async () => {
const storage = new MemoryStorage();
@@ -1102,6 +1116,113 @@ describe("ReplicaCache", () => {
).toEqual(["agent", "checkpoint", "project", "workspace"]);
});
it.each(["beforeReadAll", "beforeDeleteHost"] as const)(
"stores no checkpoint for a host evicted after its update was queued (%s)",
async (pausePoint) => {
const storage = new MemoryStorage();
const previousSession = new ReplicaCache(storage, noLegacyCleanup);
previousSession.setHosts([SERVER_ID, "other-host"]);
previousSession.replaceDirectoryBaseline(SERVER_ID, directory());
previousSession.replaceDirectoryBaseline("other-host", directory());
await previousSession.flush();
const cache = new ReplicaCache(storage, { ...noLegacyCleanup, maxBytes: 8_192 });
cache.setHosts([SERVER_ID, "other-host"]);
const paused = deferred();
const resume = deferred();
storage[pausePoint] = async () => {
storage[pausePoint] = null;
paused.resolve();
await resume.promise;
};
// Larger than the whole budget, so this persist evicts both hosts.
cache.commitTimeline(SERVER_ID, "agent-1", timeline("x".repeat(16_384)));
const eviction = cache.flush();
await paused.promise;
cache.commitDirectoryMutations(SERVER_ID, [], { agents: { generation: "g", afterSeq: 13 } });
resume.resolve();
await eviction;
await cache.flush();
const restored = await createCache(storage).readDirectory(SERVER_ID);
expect(restored.agents.size).toBe(0);
expect(restored.checkpoint).toBeUndefined();
},
);
it("stores no checkpoint for a host evicted while a malformed row is repaired", async () => {
const { storage } = await cacheWithoutBackgroundVisibility();
const reader = createCache(storage, 8_192);
storage.onRead = () => {
if (!storage.reads.at(-1)?.kinds.includes("checkpoint")) return;
storage.onRead = null;
// Larger than the whole budget, so this persist evicts the host before the repair writes.
reader.commitTimeline(SERVER_ID, "agent-1", timeline("x".repeat(16_384)));
void reader.flush();
};
expect(await reader.readWorkspace(SERVER_ID, "workspace-1")).toBeUndefined();
await reader.flush();
const restored = await createCache(storage).readDirectory(SERVER_ID);
expect(restored.projects.size).toBe(0);
expect(restored.checkpoint).toBeUndefined();
});
it("repairs a malformed row's cursor when the overlapping eviction fails", async () => {
const { storage } = await cacheWithoutBackgroundVisibility();
const reader = createCache(storage, 8_192);
storage.onRead = () => {
if (!storage.reads.at(-1)?.kinds.includes("checkpoint")) return;
storage.onRead = null;
storage.beforeDeleteHost = async () => {
storage.beforeDeleteHost = null;
throw new Error("Eviction aborted");
};
reader.commitTimeline(SERVER_ID, "agent-1", timeline("x".repeat(16_384)));
void reader.flush();
};
expect(await reader.readWorkspace(SERVER_ID, "workspace-1")).toBeUndefined();
// A newer timeline fits the budget, so no later eviction clears the checkpoint.
reader.commitTimeline(SERVER_ID, "agent-1", timeline());
await reader.flush();
const restored = await createCache(storage).readDirectory(SERVER_ID);
expect(restored.workspaces.size).toBe(0);
expect(restored.checkpoint).toEqual({
agents: { generation: "g", afterSeq: 12 },
projects: { generation: "g", afterSeq: 4 },
});
});
it("keeps an update queued behind the baseline that rebuilds an evicted host", async () => {
const storage = new MemoryStorage();
const cache = new ReplicaCache(storage, { ...noLegacyCleanup, maxBytes: 2_500 });
cache.setHosts([SERVER_ID, "other-host"]);
const baseline = directory();
cache.replaceDirectoryBaseline(SERVER_ID, baseline);
await cache.flush();
cache.replaceDirectoryBaseline("other-host", baseline);
await cache.flush();
expect((await cache.readDirectory(SERVER_ID)).agents.size).toBe(0);
const renamed = { ...agent(), title: "Renamed agent" };
cache.replaceDirectoryBaseline(SERVER_ID, baseline);
cache.commitDirectoryMutations(
SERVER_ID,
[{ kind: "agent", type: "upsert", id: renamed.id, value: renamed }],
{ agents: { generation: "g", afterSeq: 13 } },
);
await cache.flush();
cache.commitDirectoryMutations(SERVER_ID, [], { agents: { generation: "g", afterSeq: 14 } });
await cache.flush();
const restored = await createCache(storage).readDirectory(SERVER_ID);
expect(restored.checkpoint).toEqual({ agents: { generation: "g", afterSeq: 14 } });
expect(restored.agents.get(renamed.id)?.title).toBe("Renamed agent");
});
it("runs legacy cleanup once when storage is first used", async () => {
const storage = new MemoryStorage();
const cache = new ReplicaCache(storage, {
+34 -20
View File
@@ -397,15 +397,19 @@ const DirectoryCheckpointSchema = z.strictObject({
agents: DirectoryCursorSchema.optional(),
});
// Old checkpoints could describe a baseline that an overlapping refresh had discarded.
// Revalidate directory contents once without evicting cached rows or timelines.
// A checkpoint is trusted only when this version wrote it. Earlier writers could store one for a
// directory the cache no longer held: unversioned ones after an overlapping refresh, version 1
// after an eviction. Rejecting them revalidates directory contents once without evicting cached
// rows or timelines.
const DIRECTORY_CHECKPOINT_VERSION = 2;
const StoredDirectoryCheckpointSchema = z.strictObject({
version: z.literal(1),
version: z.literal(DIRECTORY_CHECKPOINT_VERSION),
cursors: DirectoryCheckpointSchema,
});
function serializeDirectoryCheckpoint(cursors: DirectoryCheckpoint) {
return { version: 1 as const, cursors };
return { version: DIRECTORY_CHECKPOINT_VERSION, cursors };
}
function deserializeDirectoryCheckpoint(payload: string): DirectoryCheckpoint {
@@ -968,6 +972,7 @@ export class ReplicaCache {
private pendingUpserts = new Map<string, StructuredReplicaUpsert>();
private pendingDeletes = new Map<string, ReplicaRowKey>();
private pendingBaselines = new Set<string>();
// Hosts whose stored directory was evicted. Only a baseline stores their directory again.
private readonly invalidatedHosts = new Set<string>();
private readonly maxBytes: number;
private totalBytes = 0;
@@ -1109,11 +1114,7 @@ export class ReplicaCache {
private async deleteInvalidRow(row: ReplicaRow): Promise<void> {
const invalidEntity = directoryEntityForRow(row);
if (!invalidEntity) {
const changes = { upserts: [], deletes: [row] } satisfies ReplicaRowChanges;
await this.queueOperation(async () => {
await this.rowStore.apply(changes);
this.applyStoredChanges(changes);
});
await this.applyRepair(row.serverId, { upserts: [], deletes: [row] });
return;
}
@@ -1144,10 +1145,7 @@ export class ReplicaCache {
]
: [],
};
await this.queueOperation(async () => {
await this.rowStore.apply(changes);
this.applyStoredChanges(changes);
});
await this.applyRepair(row.serverId, changes);
}
private async repairInvalidDirectoryRows(
@@ -1170,9 +1168,16 @@ export class ReplicaCache {
]
: [],
};
await this.queueOperation(async () => {
await this.rowStore.apply(changes);
this.applyStoredChanges(changes);
await this.applyRepair(serverId, changes);
}
// A repair is queued behind writes that can evict its host. If one did, the host has no
// directory left for the repaired checkpoint to describe, so only the deletes still apply.
private applyRepair(serverId: string, changes: ReplicaRowChanges): Promise<void> {
return this.queueOperation(async () => {
const applied = this.invalidatedHosts.has(serverId) ? { ...changes, upserts: [] } : changes;
await this.rowStore.apply(applied);
this.applyStoredChanges(applied);
});
}
@@ -1182,7 +1187,6 @@ export class ReplicaCache {
checkpoint?: DirectoryCheckpoint,
): void {
if (!this.activeServerIds.has(serverId)) return;
if (this.invalidatedHosts.has(serverId)) return;
for (const mutation of mutations) {
if (mutation.type === "delete") {
this.queueEntityDelete(serverId, mutation.kind, mutation.id);
@@ -1412,9 +1416,17 @@ export class ReplicaCache {
}
private materializePendingChanges(pending: PendingReplicaChanges): ReplicaRowChanges {
const deletes = new Map(pending.deletes.map((row) => [pendingRowKey(row), row]));
// Decided here, inside the serialized write, because eviction happens there too. A mutation
// queued before its host was evicted would otherwise store a checkpoint without its directory.
const isStorable = (row: ReplicaRowKey): boolean =>
row.kind === "timeline" ||
!this.invalidatedHosts.has(row.serverId) ||
pending.baselines.has(row.serverId);
const deletes = new Map(
pending.deletes.filter(isStorable).map((row) => [pendingRowKey(row), row]),
);
const upserts: ReplicaRow[] = [];
for (const upsert of pending.upserts) {
for (const upsert of pending.upserts.filter(isStorable)) {
const row = this.materializeUpsert(upsert);
if (row) upserts.push(row);
else deletes.set(pendingRowKey(upsert), upsert);
@@ -1563,8 +1575,10 @@ export class ReplicaCache {
projectedTotal -= bytes;
projectedBytes.delete(serverId);
evicted.add(serverId);
this.invalidatedHosts.add(serverId);
if (this.storedRows.has(serverId)) await this.rowStore.deleteHost(serverId);
// Only after the delete commits: a failed eviction leaves the rows stored, and writers that
// check this set must keep their checkpoint in step with those rows.
this.invalidatedHosts.add(serverId);
this.removeStoredHost(serverId);
}
@@ -92,13 +92,14 @@ test("visible catch-up settles before hidden open chats start fetching", async (
world.sync.dispose();
});
test("a failed visible catch-up releases hidden chats without bypassing its error", async () => {
test("a failed visible catch-up with a parked gap releases hidden chats without retrying", async () => {
const world = new TimelineWorld();
world.openedEarlier(["a-hidden"]);
world.sync.replaceVisibleAgentIds("pane", ["z-visible"]);
world.sync.setConnected(true);
(await world.nextMembership()).succeed();
const visible = await world.nextFetch("z-visible");
world.sync.recoverGap("z-visible", { epoch: "epoch-z-visible", endSeq: 1 });
world.expectNoPendingFetch();
visible.fail("temporarily unavailable");
const hidden = await world.nextFetch("a-hidden");
@@ -127,6 +128,63 @@ test("switching chats promotes the newly visible catch-up while another visible
world.sync.dispose();
});
test("reconnect drains hidden chats two at a time after the visible chat settles", async () => {
const world = new TimelineWorld();
const hidden = Array.from({ length: 15 }, (_, index) => `hidden-${10 + index}`);
world.openedEarlier(hidden);
world.show("pane", ["visible"]);
world.sync.setConnected(true);
(await world.nextMembership()).succeed();
const beforeDisconnect = await world.nextFetch("visible");
world.sync.setConnected(false);
beforeDisconnect.respond({ hasNewer: false });
world.sync.setConnected(true);
(await world.nextMembership()).succeed();
const visible = await world.nextFetch("visible");
world.expectNoPendingFetch();
visible.respond({ hasNewer: false });
const first = await world.nextFetch(hidden[0]);
let current = await world.nextFetch(hidden[1]);
world.expectNoPendingFetch();
first.fail("timeline request timed out");
for (const agentId of hidden.slice(2)) {
const next = await world.nextFetch(agentId);
world.expectNoPendingFetch();
current.respond({ hasNewer: false });
current = next;
}
current.respond({ hasNewer: false });
await vi.waitFor(() => {
expect(world.sync.getAgentTimelineStatus(hidden[0])).toBe("error");
for (const agentId of hidden.slice(1)) {
expect(world.sync.getAgentTimelineStatus(agentId)).toBe("ready");
}
});
world.expectNoPendingFetch();
world.sync.dispose();
});
test("focusing a queued chat starts it while both hidden catch-ups are running", async () => {
const world = new TimelineWorld();
world.openedEarlier(["hidden-a", "hidden-b", "next-visible"]);
world.show("pane", ["visible"]);
world.sync.setConnected(true);
(await world.nextMembership()).succeed();
(await world.nextFetch("visible")).respond({ hasNewer: false });
const first = await world.nextFetch("hidden-a");
const second = await world.nextFetch("hidden-b");
world.expectNoPendingFetch();
world.show("pane", ["next-visible"]);
expect(world.pendingFetchCount).toBe(1);
(await world.nextFetch("next-visible")).respond({ hasNewer: false });
await vi.waitFor(() => expect(world.sync.getAgentTimelineStatus("next-visible")).toBe("ready"));
first.respond({ hasNewer: false });
second.respond({ hasNewer: false });
world.sync.dispose();
});
class TimelineWorld {
constructor(
private readonly observeMembership?: ViewedTimelineSyncPorts["observe"],
@@ -441,7 +499,7 @@ test("a gap absorbed by a running tail is recovered after the tail completes", a
await vi.waitFor(() => expect(world.sync.getAgentTimelineStatus("agent-a")).toBe("ready"));
});
test("a gap parked behind a running tail resumes after the rows that tail applied", async () => {
test("a parked gap pages forward from the coverage established by the running tail", async () => {
const world = new TimelineWorld();
world.sync.setConnected(true);
world.sync.replaceVisibleAgentIds("workspace", ["agent-a"]);
@@ -460,7 +518,13 @@ test("a gap parked behind a running tail resumes after the rows that tail applie
projection: "projected",
wholeTurns: true,
});
recovery.respond({ hasNewer: false, seq: 7 });
recovery.respond({ hasNewer: true, seq: 47 });
const followUp = await world.nextFetch("agent-a");
expect(followUp.request).toMatchObject({
direction: "after",
cursor: { epoch: "epoch-agent-a", seq: 47 },
});
followUp.respond({ hasNewer: false, seq: 55 });
await vi.waitFor(() => expect(world.sync.getAgentTimelineStatus("agent-a")).toBe("ready"));
world.sync.dispose();
});
@@ -941,14 +1005,51 @@ test("redeclaring unchanged visibility does not bypass catch-up error", async ()
await world.nextError();
world.sync.replaceVisibleAgentIds("workspace", ["agent-a"]);
world.sync.setActive(false);
world.sync.setActive(true);
world.expectNoPendingMembership();
world.expectNoPendingFetch();
expect(world.sync.getAgentTimelineStatus("agent-a")).toBe("error");
});
test.each(["refocusing", "foregrounding"])(
"%s retries a timed-out visible timeline once",
async (trigger) => {
const world = new TimelineWorld();
world.show("pane", ["agent-a"]);
world.sync.setConnected(true);
(await world.nextMembership()).succeed();
(await world.nextFetch("agent-a")).fail("timeline request timed out");
await world.nextError();
expect(world.sync.getAgentTimelineStatus("agent-a")).toBe("error");
const revisit = () => {
if (trigger === "refocusing") {
world.show("pane", []);
world.show("pane", ["agent-a"]);
} else {
world.sync.setActive(false);
world.sync.setActive(true);
}
};
revisit();
expect(world.pendingFetchCount).toBe(1);
expect(world.sync.getAgentTimelineStatus("agent-a")).toBe("pending");
(await world.nextFetch("agent-a")).fail("timeline request timed out again");
await vi.waitFor(() => expect(world.errors).toHaveLength(2));
expect(world.sync.getAgentTimelineStatus("agent-a")).toBe("error");
world.show("pane", ["agent-a"]);
world.sync.setActive(true);
world.expectNoPendingFetch();
revisit();
(await world.nextFetch("agent-a")).respond({ hasNewer: false });
await vi.waitFor(() => expect(world.sync.getAgentTimelineStatus("agent-a")).toBe("ready"));
expect(world.sync.getAgentTimelineError("agent-a")).toBeNull();
world.expectNoPendingMembership();
world.sync.dispose();
},
);
test("a manual retry that fails returns to the error state", async () => {
const world = new TimelineWorld();
world.sync.setConnected(true);
@@ -968,6 +1069,37 @@ test("a manual retry that fails returns to the error state", async () => {
await vi.waitFor(() => expect(world.sync.getAgentTimelineStatus("agent-a")).toBe("error"));
});
test("refocusing during a membership update retries a reconnect without replaying the backlog", async () => {
const world = freshnessWorld();
world.cursors.set("agent-a", { epoch: "epoch-agent-a", endSeq: 42 });
world.show("pane", ["agent-a"]);
world.sync.setConnected(true);
(await world.nextMembership()).succeed({ "agent-a": "current" });
await vi.waitFor(() => expect(world.sync.getAgentTimelineStatus("agent-a")).toBe("ready"));
world.sync.setConnected(false);
world.sync.setConnected(true);
(await world.nextMembership()).succeed({ "agent-a": "behind" });
const failed = await world.nextFetch("agent-a");
expect(failed.request.direction).toBe("after");
failed.fail("timeline request timed out");
await world.nextError();
world.show("pane", ["agent-b"]);
const membership = await world.nextMembership();
world.show("pane", ["agent-a"]);
expect(world.pendingFetchCount).toBe(1);
const retry = await world.nextFetch("agent-a");
expect(retry.request).toEqual(failed.request);
membership.succeed();
retry.respond({ hasNewer: true, seq: 82 });
const tail = await world.nextFetch("agent-a");
expect(tail.request.direction).toBe("tail");
tail.respond({ hasNewer: false });
await vi.waitFor(() => expect(world.sync.getAgentTimelineStatus("agent-a")).toBe("ready"));
world.sync.dispose();
});
test("gap recovery supersedes completed catch-up and pages through the current tail", async () => {
const world = new TimelineWorld();
world.sync.setConnected(true);
@@ -545,12 +545,27 @@ export function createViewedTimelineOwner(input: {
};
}
const MAX_HIDDEN_CATCH_UPS = 2;
type CatchUpStatus = "running" | "complete" | "error";
interface CatchUpRequest {
page: ProjectedTimelineForwardFetchPlan;
kind: "resume" | "gap";
}
interface CatchUpState {
generation: number;
status: CatchUpStatus;
request?: ProjectedTimelineForwardFetchPlan;
request?: CatchUpRequest;
}
function planCatchUpRequest(
request: CatchUpRequest | undefined,
applied: { epoch: string; endSeq: number } | undefined,
): CatchUpRequest {
if (!request) return { page: planTimelineResumeFetch(applied), kind: "resume" };
return { ...request, page: planTimelineCatchUpPastApplied(request.page, applied) };
}
function isSameCatchUpRequest(
@@ -573,11 +588,11 @@ function decideCatchUp(input: {
if (input.supersede) {
if (
input.current.status === "running" &&
isSameCatchUpRequest(input.current.request, input.request)
isSameCatchUpRequest(input.current.request?.page, input.request)
) {
return "keep";
}
if (input.current.status === "running" && input.current.request?.direction === "tail") {
if (input.current.status === "running" && input.current.request?.page.direction === "tail") {
return "keep-and-park";
}
return "replace";
@@ -597,9 +612,11 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
const sources = new Map<string, string[]>();
const catchUps = new Map<string, CatchUpState>();
const catchUpGenerations = new Map<string, number>();
// Authoritative fetch owed but not runnable yet: disconnected, unacknowledged, or parked.
// Fetches can outlive their catch-up generation when superseded or when a tab closes.
const inFlightCatchUps = new Set<{ agentId: string }>();
// Authoritative fetch owed but not runnable yet: disconnected, unacknowledged, or queued.
// Membership acknowledgement and catch-up completion drain parked requests.
const pendingCatchUps = new Map<string, ProjectedTimelineForwardFetchPlan>();
const pendingCatchUps = new Map<string, CatchUpRequest>();
const visibilityCatchUpPending = new Set<string>();
const visibilityCatchUpErrors = new Map<string, string>();
// A user-initiated retry owes a pending state until it settles.
@@ -723,16 +740,16 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
const fetchUntilCurrent = async (
agentId: string,
generation: number,
request: ProjectedTimelineForwardFetchPlan,
request: CatchUpRequest,
fallbackToLatestTailOnOverflow: boolean,
): Promise<void> => {
if (!ownsCatchUp(agentId, generation)) return;
try {
const page = await ports.fetchPage(agentId, request);
const page = await ports.fetchPage(agentId, request.page);
if (!ownsCatchUp(agentId, generation)) return;
if (page.hasNewer && page.endCursor) {
if (fallbackToLatestTailOnOverflow) {
if (request.page.direction === "after" && fallbackToLatestTailOnOverflow) {
await ports.fetchLatestTail(agentId);
if (!ownsCatchUp(agentId, generation)) return;
catchUps.set(agentId, { generation, status: "complete" });
@@ -742,10 +759,13 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
await fetchUntilCurrent(
agentId,
generation,
planTimelineCatchUpPastApplied(
planTimelineCatchUpAfter(page.endCursor),
ports.readCursor(agentId),
),
{
...request,
page: planTimelineCatchUpPastApplied(
planTimelineCatchUpAfter(page.endCursor),
ports.readCursor(agentId),
),
},
false,
);
return;
@@ -754,20 +774,15 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
throw new Error(`Timeline page for ${agentId} hasNewer without an end cursor`);
}
catchUps.set(agentId, { generation, status: "complete" });
const pendingCatchUp = pendingCatchUps.get(agentId);
if (pendingCatchUp) {
startCatchUp(agentId, { request: pendingCatchUp, supersede: true });
return;
}
setVisibilityCatchUpReady(agentId);
if (!pendingCatchUps.has(agentId)) setVisibilityCatchUpReady(agentId);
} catch (error) {
if (catchUps.get(agentId)?.generation === generation) {
// The parked follow-up belongs to the failed attempt. A retry owns the next request.
pendingCatchUps.delete(agentId);
catchUps.set(agentId, { generation, status: "error", request });
setVisibilityCatchUpError([agentId], error);
ports.reportError(error);
}
} finally {
startAcknowledgedCatchUps();
}
};
@@ -798,23 +813,29 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
);
};
const hiddenCatchUpSlotsAreFull = (agentId: string) => {
const visible = new Set(visibleAgentIds());
if (visible.has(agentId)) return false;
let hidden = 0;
for (const attempt of inFlightCatchUps) {
if (!visible.has(attempt.agentId)) hidden += 1;
}
return hidden >= MAX_HIDDEN_CATCH_UPS;
};
const startCatchUp = (
agentId: string,
options: {
request?: ProjectedTimelineForwardFetchPlan;
request?: CatchUpRequest;
supersede?: boolean;
} = {},
) => {
const { request, supersede = false } = options;
if (freshnessChecks.has(agentId)) {
if (request) pendingCatchUps.set(agentId, request);
return;
}
if (!canCatchUp(agentId)) {
if (request) pendingCatchUps.set(agentId, request);
return;
}
if (shouldWaitForVisibleCatchUp(agentId)) {
if (
freshnessChecks.has(agentId) ||
!canCatchUp(agentId) ||
shouldWaitForVisibleCatchUp(agentId)
) {
if (request) pendingCatchUps.set(agentId, request);
return;
}
@@ -824,11 +845,9 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
return;
}
const applied = ports.readCursor(agentId);
const nextRequest = request
? planTimelineCatchUpPastApplied(request, applied)
: planTimelineResumeFetch(applied);
const nextRequest = planCatchUpRequest(request, applied);
const current = catchUps.get(agentId);
const decision = decideCatchUp({ current, request: nextRequest, supersede });
const decision = decideCatchUp({ current, request: nextRequest.page, supersede });
if (decision === "keep-and-park") {
pendingCatchUps.set(agentId, nextRequest);
return;
@@ -836,18 +855,31 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
if (decision === "keep") {
return;
}
if (hiddenCatchUpSlotsAreFull(agentId)) {
if (request) pendingCatchUps.set(agentId, request);
return;
}
const generation = (catchUpGenerations.get(agentId) ?? 0) + 1;
catchUpGenerations.set(agentId, generation);
catchUps.set(agentId, { generation, status: "running", request: nextRequest });
pendingCatchUps.delete(agentId);
// A gap recovery pages forward to keep the coverage it extends. Without coverage there is
// nothing to keep, so an overflowing page falls back to the latest tail, as a resume does.
const attempt = { agentId };
inFlightCatchUps.add(attempt);
if (current?.status === "error" && !manualRetries.has(agentId)) {
visibilityCatchUpErrors.delete(agentId);
markCatchUpOwed(agentId);
notifyListeners();
}
// A queued gap uses the coverage available when its fetch starts.
void fetchUntilCurrent(
agentId,
generation,
nextRequest,
nextRequest.direction === "after" && (request === undefined || applied === undefined),
);
nextRequest.kind === "resume" || !applied,
).finally(() => {
inFlightCatchUps.delete(attempt);
startAcknowledgedCatchUps();
});
};
const startAcknowledgedCatchUps = () => {
@@ -859,9 +891,8 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
for (const agentId of ordered) {
const pendingCatchUp = pendingCatchUps.get(agentId);
const current = catchUps.get(agentId);
// Completion of a different chat must not bypass a failed chat's error or
// supersede an in-flight tail that owns its parked gap recovery.
if (current && !(current.status === "complete" && pendingCatchUp)) continue;
// A running tail owns its parked gap. A failed catch-up can only have a queued retry.
if (current?.status === "running" || (current && !pendingCatchUp)) continue;
startCatchUp(agentId, {
request: pendingCatchUp,
supersede: Boolean(pendingCatchUp),
@@ -869,6 +900,13 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
}
};
const retryFailedCatchUp = (agentId: string) => {
const catchUp = catchUps.get(agentId);
if (catchUp?.status === "error") {
startCatchUp(agentId, { request: catchUp.request, supersede: true });
}
};
const membershipIsSettled = (requested: string[]) =>
!membershipNeedsRetry &&
!freshnessCheckOwed &&
@@ -975,9 +1013,7 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
void reconcileMembership();
return;
}
if (catchUp?.status === "error") {
startCatchUp(agentId, { request: catchUp.request, supersede: true });
}
retryFailedCatchUp(agentId);
};
const commitDesiredMembership = (
@@ -1068,11 +1104,17 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
publishVisibleMembership();
},
replaceVisibleAgentIds(sourceId, agentIds) {
const previouslyVisible = new Set(visibleAgentIds());
const normalized = normalizeAgentIds(agentIds);
if (normalized.length === 0) sources.delete(sourceId);
else sources.set(sourceId, normalized);
rememberOpenedAgentIds(normalized);
publishVisibleMembership();
if (active) {
for (const agentId of normalized) {
if (!previouslyVisible.has(agentId)) retryFailedCatchUp(agentId);
}
}
startAcknowledgedCatchUps();
},
setActive(nextActive) {
@@ -1085,7 +1127,10 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
}
const canCheck = connected && ports.canCheckFreshness();
for (const agentId of visibleAgentIds()) {
if (visibilityCatchUpErrors.has(agentId)) continue;
if (visibilityCatchUpErrors.has(agentId)) {
retryFailedCatchUp(agentId);
continue;
}
markCatchUpOwed(agentId);
if (
canCheck &&
@@ -1132,7 +1177,10 @@ export function createViewedTimelineSync(ports: ViewedTimelineSyncPorts): Viewed
recoverGap(agentId, cursor) {
if (!isDesired(agentId) || catchUps.get(agentId)?.status === "error") return;
startCatchUp(agentId, {
request: planTimelineCatchUpAfter({ epoch: cursor.epoch, seq: cursor.endSeq }),
request: {
page: planTimelineCatchUpAfter({ epoch: cursor.epoch, seq: cursor.endSeq }),
kind: "gap",
},
supersede: true,
});
},
@@ -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`,
});
});
+12 -1
View File
@@ -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);
+100
View File
@@ -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();
+19 -3
View File
@@ -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,
});
}
+72
View File
@@ -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([]);
});
});
@@ -89,6 +89,9 @@ export async function createAcpProviderConnection(
if (probe.agentCapabilities.loadSession) {
supportedCapabilities.push("session.persistence");
}
if (options.acpOptions?.deferTurnOnRunningTools) {
supportedCapabilities.push("prompt.steer");
}
await probe.close();
const capabilities = negotiateProviderCapabilities(request.capabilities, supportedCapabilities);
const listeners = new Set<(event: ProviderEvent) => void>();
@@ -214,10 +217,13 @@ async function dispatch(input: ProviderInput, state: AcpConnectionState): Promis
await mutateSession(session, () => session.runtime.prompt(input));
return;
}
case "session.interrupt":
await requireSession(state, input.sessionId).runtime.interrupt();
case "session.interrupt": {
const session = requireSession(state, input.sessionId);
const retired = await session.runtime.interrupt();
state.emit({ type: "request.completed", requestId: input.requestId });
if (retired) retireSession(state, input.sessionId);
return;
}
case "session.permission":
requireSession(state, input.sessionId).runtime.respondToPermission(
input.permissionId,
@@ -304,6 +310,12 @@ async function listSessions(
}
}
function retireSession(state: AcpConnectionState, sessionId: string): void {
if (state.sessions.delete(sessionId)) {
state.emit({ type: "session.closed", sessionId });
}
}
async function openSession(
input: Extract<ProviderInput, { type: "session.open" }>,
state: AcpConnectionState,
@@ -317,6 +329,7 @@ async function openSession(
cwd: input.config.cwd,
env: input.config.env,
emit: state.emit,
onRetired: () => retireSession(state, input.sessionId),
});
try {
const capabilities = await runtime.open(input, state.capabilities);
@@ -358,6 +371,7 @@ interface StartRuntimeOptions {
cwd?: string;
env: Readonly<Record<string, string>>;
emit(event: ProviderEvent): void;
onRetired?: () => void;
}
interface PendingPermission {
@@ -366,6 +380,33 @@ interface PendingPermission {
resolve(response: RequestPermissionResponse): void;
}
type DeferredTurnOutcome =
| { type: "complete"; terminalizeTools: boolean }
| { type: "cancel" }
| { type: "fail"; error: { message: string } };
interface DeferredTurnState {
timer: ReturnType<typeof setTimeout> | null;
resolve(outcome: DeferredTurnOutcome): void;
}
type DeferredReplyState = "idle" | "open" | "settled_with_open_tools" | "settled";
interface ActivePrompt {
turnId: string;
settled: Promise<void>;
cancelling: boolean;
wirePromptsInFlight: number;
wirePromptLane: Promise<void>;
lastPromptResponseWireSeq: number | null;
crossedEndTurn: boolean;
replyState: DeferredReplyState;
deferred: DeferredTurnState | null;
}
const DEFAULT_DEFERRED_SETTLE_DELAY_MS = 500;
const DEFAULT_DEFERRED_QUIET_LIMIT_MS = 120_000;
class AcpRuntime {
readonly connection: ClientSideConnection;
agentCapabilities: AgentCapabilities = {};
@@ -374,6 +415,8 @@ class AcpRuntime {
private emit: (event: ProviderEvent) => void;
private readonly messages = new Map<string, string>();
private readonly toolCalls = new Map<string, AcpToolCallSnapshot>();
private readonly liveOpenToolIds = new Set<string>();
private readonly canceledToolCallIds = new Set<string>();
// Running tool rows published by transformers; the turn's terminal closes any left open.
private readonly vendorToolCalls = new Map<string, ToolCallTimelineItem>();
private readonly pendingCompactions = new Set<string>();
@@ -401,21 +444,33 @@ class AcpRuntime {
private replayWindow: "replay" | "skip" | null = null;
private lastLoadUpdateAt = 0;
private closing = false;
private closePromise: Promise<void> | null = null;
private deferredRetirement: Promise<boolean> | null = null;
private deferredFinalized = false;
private processFailed = false;
private configTransaction = false;
private stagedTransformerConfig: ProviderConfigState | null = null;
private readonly closeConnector: () => Promise<void>;
private readonly closeConnector: (options?: {
force?: boolean;
timeoutMs?: number;
}) => Promise<void>;
private readonly whenConnectorClosed: () => Promise<void> | null;
private notificationLane: Promise<void> = Promise.resolve();
private incomingWireSeq = 0;
private readonly sessionUpdateWireSeqs: number[] = [];
private autoAccept = false;
private activePrompt: { turnId: string; settled: Promise<void>; cancelling: boolean } | null =
null;
private activePrompt: ActivePrompt | null = null;
private lastUsage: ProviderUsage = {};
static async start(options: StartRuntimeOptions): Promise<AcpRuntime> {
let child: ChildProcessWithoutNullStreams | null = null;
let spawnFailure: Promise<never> | null = null;
let stream: Stream;
let closeConnector = async () => {};
let closeConnector: (options?: {
force?: boolean;
timeoutMs?: number;
}) => Promise<void> = async () => {};
let whenConnectorClosed: () => Promise<void> | null = () => null;
if (options.options.command) {
// COMPAT(pluginProviderLaunch): added in v0.10.0, remove after 2027-03-29 once plugin host floor >= v0.10.0.
// Standalone callers and older hosts do not send a daemon-resolved launch.
@@ -438,8 +493,9 @@ class AcpRuntime {
const owned = ownConnectorStream(await options.options.connector());
stream = owned.stream;
closeConnector = owned.close;
whenConnectorClosed = owned.whenClosed;
}
const runtime = new AcpRuntime(stream, child, closeConnector, options);
const runtime = new AcpRuntime(stream, child, closeConnector, whenConnectorClosed, options);
try {
const initialize = withTimeout(
runtime.call(
@@ -466,41 +522,51 @@ class AcpRuntime {
private constructor(
stream: Stream,
child: ChildProcessWithoutNullStreams | null,
closeConnector: () => Promise<void>,
closeConnector: (options?: { force?: boolean; timeoutMs?: number }) => Promise<void>,
whenConnectorClosed: () => Promise<void> | null,
private readonly options: StartRuntimeOptions,
) {
this.child = child;
this.closeConnector = closeConnector;
this.whenConnectorClosed = whenConnectorClosed;
this.emit = options.emit;
this.transformers = options.options.transformers ?? [];
const client: Client = {
requestPermission: (request) => this.requestPermission(request),
sessionUpdate: (notification) =>
this.enqueueNotification(() => this.sessionUpdate(notification)),
sessionUpdate: (notification) => {
const wireSeq = this.sessionUpdateWireSeqs.shift() ?? ++this.incomingWireSeq;
return this.enqueueNotification(() => this.sessionUpdate(notification, wireSeq));
},
};
this.connection = new ClientSideConnection(
() => client,
routeVendorNotifications(stream, (method, params) => this.vendorNotification(method, params)),
routeIncomingMessages(
stream,
(method, params) => this.vendorNotification(method, params),
(message) => this.observeWireMessage(message),
),
);
if (!child) void this.connection.closed.then(() => this.handleUnexpectedTransportClose());
child?.on("error", (error) => {
const message = describeError(error);
this.processFailed = true;
this.settlePendingWork();
this.settlePendingWork(message);
if (this.closing || !this.nativeSessionId) return;
this.emit({
type: "session.runtime_failed",
sessionId: this.options.boundarySessionId,
error: { message: describeError(error) },
error: { message },
});
});
child?.once("close", (code, signal) => {
if (this.closing || this.processFailed || !this.nativeSessionId) return;
const message = `ACP process exited (${signal ?? code ?? "unknown"})`;
this.processFailed = true;
this.settlePendingWork();
this.settlePendingWork(message);
this.emit({
type: "session.runtime_failed",
sessionId: this.options.boundarySessionId,
error: { message: `ACP process exited (${signal ?? code ?? "unknown"})` },
error: { message },
});
});
}
@@ -609,10 +675,31 @@ class AcpRuntime {
}
async prompt(input: Extract<ProviderInput, { type: "session.prompt" }>): Promise<void> {
if (this.closing || this.processFailed || this.deferredRetirement) {
throw new Error("ACP session is closed");
}
if (input.prompt.delivery === "steer") {
this.steerDeferredPrompt(input);
return;
}
const active = this.activePrompt;
if (active) {
await this.interrupt();
if (active.deferred && active.wirePromptsInFlight === 0) {
// Wire session/prompt already resolved; finish the deferred turn without sending
// session/cancel so running background tools stay alive into the follow-up turn.
this.finishDeferredTurn(active, { type: "complete", terminalizeTools: false });
} else {
const retired = await this.interrupt();
if (retired) {
// Notify caller that the session closed before failing the replacement prompt.
this.options.onRetired?.();
throw new Error("ACP session retired after stopping deferred background work");
}
}
await active.settled;
if (this.closing || this.processFailed || this.deferredRetirement) {
throw new Error("ACP session is closed");
}
}
const prompt = toAcpPrompt(input.prompt);
this.replayWindow = null;
@@ -643,6 +730,17 @@ class AcpRuntime {
turnId,
state: "started",
});
const activePrompt: ActivePrompt = {
turnId,
settled: Promise.resolve(),
cancelling: false,
wirePromptsInFlight: 1,
wirePromptLane: Promise.resolve(),
lastPromptResponseWireSeq: null,
crossedEndTurn: false,
replyState: "idle",
deferred: null,
};
// The SDK dispatches notifications without awaiting them, so the prompt response can resolve
// while earlier session updates are still queued. Apply them before the turn ends.
const settled = this.call(
@@ -650,6 +748,7 @@ class AcpRuntime {
).then(
async (response): Promise<void> => {
await this.drainNotifications();
activePrompt.wirePromptsInFlight -= 1;
if (response.usage) {
this.lastUsage = {
...this.lastUsage,
@@ -665,47 +764,95 @@ class AcpRuntime {
});
}
const state = response.stopReason === "cancelled" ? "canceled" : "completed";
this.fallbackChunkIds.clear();
this.terminalizeTransientItems(state);
this.finishTurnPermissions(turnId);
this.emit({
type: "session.turn",
sessionId: this.options.boundarySessionId,
turnId,
state,
});
if (response.stopReason === "end_turn" && this.shouldDeferTurn(activePrompt)) {
await this.settleDeferredPrompt(activePrompt);
return undefined;
}
this.finishPromptTurn(turnId, state);
return undefined;
},
async (error): Promise<void> => {
await this.drainNotifications();
this.fallbackChunkIds.clear();
this.terminalizeTransientItems("failed");
this.finishTurnPermissions(turnId);
this.emit({
type: "session.turn",
sessionId: this.options.boundarySessionId,
turnId,
state: "failed",
error: { message: describeError(error) },
});
activePrompt.wirePromptsInFlight -= 1;
this.finishPromptTurn(turnId, "failed", { message: describeError(error) });
return undefined;
},
);
this.activePrompt = { turnId, settled, cancelling: false };
activePrompt.settled = settled;
this.activePrompt = activePrompt;
void settled.finally(() => {
if (this.activePrompt?.turnId === turnId) this.activePrompt = null;
});
}
async interrupt(): Promise<void> {
async interrupt(): Promise<boolean> {
if (this.deferredRetirement) return this.deferredRetirement;
const active = this.activePrompt;
const deferredTurnId = active?.deferred ? active.turnId : null;
if (active && deferredTurnId) {
const retirement = this.retireDeferredTurn(active, deferredTurnId).catch((error) => {
if (this.deferredRetirement === retirement) this.deferredRetirement = null;
throw error;
});
this.deferredRetirement = retirement;
return retirement;
}
if (active) active.cancelling = true;
try {
await this.call(this.connection.cancel({ sessionId: this.nativeSessionId }));
} finally {
// An agent may wait for its outstanding permission replies before ending the prompt.
if (active) this.finishTurnPermissions(active.turnId);
if (active) {
this.finishTurnPermissions(active.turnId);
}
}
return false;
}
private finalizeDeferredTurn(deferredTurnId: string, emitRetired: boolean): void {
if (this.deferredFinalized) return;
this.deferredFinalized = true;
this.finishPromptTurn(deferredTurnId, "canceled", undefined, {
suppressTrailingToolEcho: true,
});
if (emitRetired) this.options.onRetired?.();
}
private async retireDeferredTurn(active: ActivePrompt, deferredTurnId: string): Promise<boolean> {
active.cancelling = true;
// Record open tools owned by Stop before writing session/cancel so any failure
// update arriving during cancel preserves their canceled state.
for (const id of this.liveOpenToolIds) this.canceledToolCallIds.add(id);
let cancelTimedOut = false;
if (!this.closing) {
try {
await withTimeout(
this.call(this.connection.cancel({ sessionId: this.nativeSessionId })),
1_000,
`ACP session ${this.nativeSessionId} did not accept cancel`,
);
} catch {
cancelTimedOut = true;
} finally {
// An agent may wait for its outstanding permission replies before ending the prompt.
this.finishTurnPermissions(active.turnId);
}
}
// ACP v1 has no response or end boundary for session/cancel once session/prompt
// already returned. Close the process first while the turn still appears running,
// then emit the canceled turn synchronously before request.completed and session.closed
// so queued work and config changes immediately observe the retired session.
try {
await this.close({ force: cancelTimedOut, timeoutMs: 1_000 });
} catch (error) {
void this.whenConnectorClosed()?.then(
() => this.finalizeDeferredTurn(deferredTurnId, true),
() => undefined,
);
throw error;
}
this.finalizeDeferredTurn(deferredTurnId, false);
return true;
}
listSessions(cwd?: string) {
@@ -758,6 +905,7 @@ class AcpRuntime {
sessionId: this.options.boundarySessionId,
permissionId,
});
if (this.activePrompt?.deferred) this.scheduleDeferredSettle();
}
async configure(
@@ -833,11 +981,20 @@ class AcpRuntime {
await this.close();
}
async close(): Promise<void> {
if (this.closing) return;
close(options?: { force?: boolean; timeoutMs?: number }): Promise<void> {
if (this.closePromise) return this.closePromise;
this.closing = true;
const promise = this.closeInternal(options).catch((error) => {
if (this.closePromise === promise) this.closePromise = null;
throw error;
});
this.closePromise = promise;
return promise;
}
private async closeInternal(options?: { force?: boolean; timeoutMs?: number }): Promise<void> {
this.settlePendingWork();
await this.closeConnector();
await this.closeConnector(options);
const child = this.child;
if (!child || this.processFailed) return;
if (child.exitCode !== null || child.signalCode !== null) return;
@@ -1066,6 +1223,7 @@ class AcpRuntime {
const permissionId = `permission:${request.toolCall.toolCallId}`;
return new Promise((resolve) => {
this.permissions.set(permissionId, { request, resolve, turnId: this.activePrompt?.turnId });
if (this.activePrompt?.deferred) this.scheduleDeferredSettle();
this.emit({
type: "session.permission",
sessionId: this.options.boundarySessionId,
@@ -1085,7 +1243,31 @@ class AcpRuntime {
});
}
private sessionUpdate(notification: SessionNotification): void {
private observeWireMessage(message: unknown): void {
if (typeof message !== "object" || message === null) return;
const record = message as Record<string, unknown>;
if (record.method === "session/update") {
this.sessionUpdateWireSeqs.push(++this.incomingWireSeq);
return;
}
if (
!("method" in record) &&
"id" in record &&
typeof record.result === "object" &&
record.result !== null &&
typeof (record.result as Record<string, unknown>).stopReason === "string" &&
this.activePrompt &&
this.activePrompt.lastPromptResponseWireSeq === null
) {
this.activePrompt.lastPromptResponseWireSeq = ++this.incomingWireSeq;
}
}
private isPostWirePrompt(active: ActivePrompt, wireSeq: number): boolean {
return active.lastPromptResponseWireSeq !== null && wireSeq > active.lastPromptResponseWireSeq;
}
private sessionUpdate(notification: SessionNotification, wireSeq: number): void {
if (notification.sessionId !== this.nativeSessionId) return;
if (this.replayWindow) this.lastLoadUpdateAt = performance.now();
if (this.replayWindow === "skip") {
@@ -1096,7 +1278,7 @@ class AcpRuntime {
update.sessionUpdate === "current_mode_update" ||
update.sessionUpdate === "usage_update"
) {
this.reduceStateUpdate(update);
this.reduceStateUpdate(update, wireSeq);
}
return;
}
@@ -1107,10 +1289,10 @@ class AcpRuntime {
this.reduceUserMessageChunk(notification.update);
return;
}
this.reduceUpdate(notification.update);
this.reduceUpdate(notification.update, wireSeq);
}
private reduceUpdate(update: SessionUpdate): void {
private reduceUpdate(update: SessionUpdate, wireSeq: number): void {
if (
update.sessionUpdate === "agent_message_chunk" ||
update.sessionUpdate === "agent_thought_chunk" ||
@@ -1144,15 +1326,16 @@ class AcpRuntime {
: {}),
},
});
this.noteDeferredChunk(update.sessionUpdate, wireSeq);
return;
}
if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
if (update.sessionUpdate === "tool_call") this.fallbackChunkIds.clear();
this.reduceToolCall(update);
this.reduceToolCall(update, wireSeq);
return;
}
if (update.sessionUpdate === "plan") this.fallbackChunkIds.clear();
this.reduceStateUpdate(update);
this.reduceStateUpdate(update, wireSeq);
}
// Historical user messages arrive only as replayed chunks; a live prompt
@@ -1196,7 +1379,7 @@ class AcpRuntime {
return id;
}
private reduceStateUpdate(update: SessionUpdate): void {
private reduceStateUpdate(update: SessionUpdate, wireSeq: number): void {
if (update.sessionUpdate === "plan") {
this.emit({
type: "timeline.item",
@@ -1253,6 +1436,7 @@ class AcpRuntime {
sessionId: this.options.boundarySessionId,
usage: this.lastUsage,
});
this.noteDeferredUsageUpdate(wireSeq);
return;
}
if (update.sessionUpdate === "compaction_update") {
@@ -1267,12 +1451,20 @@ class AcpRuntime {
status: update.status === "completed" ? "completed" : "loading",
},
});
if (this.activePrompt?.deferred) this.scheduleDeferredSettle();
}
}
private terminalizeTransientItems(state: "completed" | "failed" | "canceled"): void {
private terminalizeTransientItems(
state: "completed" | "failed" | "canceled",
options?: { preserveQualifyingOpenTools?: boolean; suppressTrailingToolEcho?: boolean },
): void {
const preserve = options?.preserveQualifyingOpenTools === true;
for (const [id, snapshot] of this.toolCalls) {
if (snapshot.status !== "pending" && snapshot.status !== "in_progress") continue;
if (preserve && this.liveOpenToolIds.has(id) && this.toolKeepsTurnOpen(snapshot)) continue;
this.liveOpenToolIds.delete(id);
if (options?.suppressTrailingToolEcho) this.canceledToolCallIds.add(id);
const completed: AcpToolCallSnapshot = {
...snapshot,
status: state === "completed" ? "completed" : "failed",
@@ -1302,18 +1494,42 @@ class AcpRuntime {
this.pendingCompactions.clear();
}
private reduceToolCall(update: ToolCall | ToolCallUpdate): void {
private reduceToolCall(
update: Extract<SessionUpdate, { sessionUpdate: "tool_call" | "tool_call_update" }>,
wireSeq: number,
): void {
if (
update.sessionUpdate === "tool_call_update" &&
this.canceledToolCallIds.has(update.toolCallId)
) {
return;
}
if (update.sessionUpdate === "tool_call") {
this.canceledToolCallIds.delete(update.toolCallId);
}
const current = this.toolCalls.get(update.toolCallId);
const wasOpenQualifying =
current !== undefined &&
this.liveOpenToolIds.has(current.id) &&
this.toolKeepsTurnOpen(current);
let snapshot = mergeToolCallSnapshot(update, current);
const context = { sessionId: this.options.boundarySessionId };
for (const transformer of this.transformers)
snapshot = transformer.toolCall?.(snapshot, context) ?? snapshot;
this.toolCalls.set(snapshot.id, snapshot);
const isOpen = snapshot.status === "pending" || snapshot.status === "in_progress";
if (this.replayWindow === null) {
if (isOpen) this.liveOpenToolIds.add(snapshot.id);
else this.liveOpenToolIds.delete(snapshot.id);
}
this.emit({
type: "timeline.item",
sessionId: this.options.boundarySessionId,
item: toolTimelineItem(snapshot),
});
const isOpenQualifying =
this.liveOpenToolIds.has(snapshot.id) && this.toolKeepsTurnOpen(snapshot);
this.noteDeferredToolTransition(wasOpenQualifying, isOpenQualifying, isOpen, snapshot, wireSeq);
}
private vendorNotification(method: string, params: unknown): void {
@@ -1376,25 +1592,306 @@ class AcpRuntime {
private handleUnexpectedTransportClose(): void {
if (this.closing || this.processFailed) return;
const message = "ACP transport closed unexpectedly";
this.processFailed = true;
this.settlePendingWork();
this.settlePendingWork(message);
if (!this.nativeSessionId) return;
this.emit({
type: "session.runtime_failed",
sessionId: this.options.boundarySessionId,
error: { message: "ACP transport closed unexpectedly" },
error: { message },
});
}
private settlePendingWork(): void {
private settlePendingWork(failureMessage?: string): void {
for (const permission of this.permissions.values()) {
permission.resolve({ outcome: { outcome: "cancelled" } });
}
this.permissions.clear();
if (this.activePrompt?.deferred) {
this.finishDeferredTurn(
this.activePrompt,
failureMessage ? { type: "fail", error: { message: failureMessage } } : { type: "cancel" },
);
}
this.commandWaiter?.();
this.commandWaiter = null;
}
private finishPromptTurn(
turnId: string,
state: "completed" | "failed" | "canceled",
error?: { message: string },
options?: { preserveQualifyingOpenTools?: boolean; suppressTrailingToolEcho?: boolean },
): void {
this.fallbackChunkIds.clear();
this.terminalizeTransientItems(state, options);
this.finishTurnPermissions(turnId);
if (state === "failed") {
this.emit({
type: "session.turn",
sessionId: this.options.boundarySessionId,
turnId,
state,
error: error ?? { message: "ACP turn failed" },
});
return;
}
this.emit({
type: "session.turn",
sessionId: this.options.boundarySessionId,
turnId,
state,
});
}
private steerDeferredPrompt(input: Extract<ProviderInput, { type: "session.prompt" }>): void {
const active = this.activePrompt;
const deferred = active?.deferred;
if (!active || !deferred || active.cancelling || this.closing || this.processFailed) {
this.emit({
type: "session.prompt_result",
sessionId: this.options.boundarySessionId,
clientMessageId: input.prompt.clientMessageId,
result: {
type: "failed",
error: {
message: "ACP session can only steer while waiting on deferred background tools",
},
},
});
return;
}
if (input.prompt.clearPendingPermissions) {
this.finishTurnPermissions(active.turnId);
}
const prompt = toAcpPrompt(input.prompt);
active.wirePromptsInFlight += 1;
this.scheduleDeferredSettle();
this.replayWindow = null;
this.fallbackChunkIds.clear();
this.emit({
type: "timeline.item",
sessionId: this.options.boundarySessionId,
item: {
type: "user_message",
id: input.prompt.clientMessageId,
text: prompt
.filter((part) => part.type === "text")
.map((part) => part.text)
.join("\n"),
clientMessageId: input.prompt.clientMessageId,
},
});
this.emit({
type: "session.prompt_result",
sessionId: this.options.boundarySessionId,
clientMessageId: input.prompt.clientMessageId,
result: { type: "steer", turnId: active.turnId },
});
const runSteer = async (): Promise<void> => {
try {
if (
this.closing ||
this.processFailed ||
active.cancelling ||
active.deferred !== deferred
) {
return;
}
this.fallbackChunkIds.clear();
active.lastPromptResponseWireSeq = null;
if (active.replyState === "settled_with_open_tools") active.replyState = "idle";
const response = await this.call(
this.connection.prompt({ sessionId: this.nativeSessionId, prompt }),
);
await this.drainNotifications();
if (this.closing || this.deferredRetirement || active.deferred !== deferred) return;
if (response.usage) {
this.lastUsage = {
...this.lastUsage,
inputTokens: response.usage.inputTokens,
outputTokens: response.usage.outputTokens,
cachedInputTokens: response.usage.cachedReadTokens ?? undefined,
};
this.emit({
type: "session.usage",
sessionId: this.options.boundarySessionId,
turnId: active.turnId,
usage: this.lastUsage,
});
}
if (response.stopReason === "cancelled") {
this.finishDeferredTurn(active, { type: "cancel" });
return;
}
if (response.stopReason !== "end_turn" && active.wirePromptsInFlight === 1) {
this.finishDeferredTurn(active, { type: "complete", terminalizeTools: true });
}
} catch (error) {
await this.drainNotifications();
if (this.closing || this.deferredRetirement || active.deferred !== deferred) return;
if (this.processFailed) {
this.finishDeferredTurn(active, {
type: "fail",
error: { message: describeError(error) },
});
} else {
this.emit({
type: "session.notice",
sessionId: this.options.boundarySessionId,
notice: {
id: `acp:steer-error:${input.prompt.clientMessageId}`,
severity: "error",
title: "Follow-up prompt failed",
description: describeError(error),
},
});
}
} finally {
if (active.lastPromptResponseWireSeq === null) {
active.lastPromptResponseWireSeq = this.incomingWireSeq;
}
active.wirePromptsInFlight -= 1;
this.scheduleDeferredSettle();
}
};
active.wirePromptLane = active.wirePromptLane.then(runSteer);
}
private async settleDeferredPrompt(active: ActivePrompt): Promise<void> {
this.fallbackChunkIds.clear();
const outcome = await new Promise<DeferredTurnOutcome>((resolve) => {
active.deferred = { timer: null, resolve };
this.scheduleDeferredSettle();
});
if (this.closing || this.deferredRetirement) return;
if (outcome.type === "fail") {
this.finishPromptTurn(active.turnId, "failed", outcome.error);
return;
}
this.finishPromptTurn(
active.turnId,
outcome.type === "cancel" ? "canceled" : "completed",
undefined,
{
preserveQualifyingOpenTools: outcome.type === "complete" && !outcome.terminalizeTools,
suppressTrailingToolEcho: outcome.type === "cancel",
},
);
}
private toolKeepsTurnOpen(snapshot: AcpToolCallSnapshot): boolean {
const defer = this.options.options.acpOptions?.deferTurnOnRunningTools;
if (!defer) return false;
return defer.keepsTurnOpen ? defer.keepsTurnOpen(snapshot) : true;
}
private hasQualifyingOpenTools(): boolean {
for (const id of this.liveOpenToolIds) {
const snapshot = this.toolCalls.get(id);
if (snapshot && this.toolKeepsTurnOpen(snapshot)) return true;
}
return false;
}
private hasDeferredBlockers(): boolean {
return (
(this.activePrompt?.wirePromptsInFlight ?? 0) > 0 ||
this.hasQualifyingOpenTools() ||
this.permissions.size > 0 ||
this.pendingCompactions.size > 0
);
}
private shouldDeferTurn(active: ActivePrompt): boolean {
if (!this.options.options.acpOptions?.deferTurnOnRunningTools) return false;
if (active.cancelling || this.closing || this.processFailed) return false;
return this.hasQualifyingOpenTools() || active.crossedEndTurn;
}
private finishDeferredTurn(active: ActivePrompt, outcome: DeferredTurnOutcome): void {
const deferred = active.deferred;
if (!deferred) return;
if (deferred.timer) clearTimeout(deferred.timer);
active.deferred = null;
deferred.resolve(outcome);
}
private noteDeferredToolTransition(
wasOpenQualifying: boolean,
isOpenQualifying: boolean,
isOpen: boolean,
snapshot: AcpToolCallSnapshot,
wireSeq: number,
): void {
const active = this.activePrompt;
if (!active || wasOpenQualifying === isOpenQualifying) return;
if (!active.deferred && !this.isPostWirePrompt(active, wireSeq)) return;
if (!active.deferred && wasOpenQualifying && !isOpen && this.toolKeepsTurnOpen(snapshot)) {
active.crossedEndTurn = true;
}
if (isOpenQualifying) active.replyState = "idle";
if (active.deferred) this.scheduleDeferredSettle();
}
private noteDeferredChunk(
kind: "agent_message_chunk" | "agent_thought_chunk",
wireSeq: number,
): void {
const active = this.activePrompt;
if (!active || !this.isPostWirePrompt(active, wireSeq)) return;
if (kind === "agent_message_chunk") active.replyState = "open";
else if (active.replyState !== "open") active.replyState = "idle";
if (active.deferred) this.scheduleDeferredSettle();
}
private noteDeferredUsageUpdate(wireSeq: number): void {
const active = this.activePrompt;
if (!active || !this.isPostWirePrompt(active, wireSeq) || active.replyState !== "open") return;
active.replyState = this.hasQualifyingOpenTools() ? "settled_with_open_tools" : "settled";
if (active.deferred) this.scheduleDeferredSettle();
}
private scheduleDeferredSettle(): void {
const active = this.activePrompt;
const deferred = active?.deferred;
const config = this.options.options.acpOptions?.deferTurnOnRunningTools;
if (!active || !deferred || !config || active.cancelling) return;
if (deferred.timer) {
clearTimeout(deferred.timer);
deferred.timer = null;
}
if (this.hasDeferredBlockers()) return;
const settled =
active.replyState === "settled" || active.replyState === "settled_with_open_tools";
const delayMs = settled
? (config.settleDelayMs ?? DEFAULT_DEFERRED_SETTLE_DELAY_MS)
: (config.quietLimitMs ?? DEFAULT_DEFERRED_QUIET_LIMIT_MS);
deferred.timer = setTimeout(() => {
deferred.timer = null;
void this.trySettleDeferredTurn(active, deferred);
}, delayMs);
}
private async trySettleDeferredTurn(
active: ActivePrompt,
deferred: DeferredTurnState,
): Promise<void> {
await this.drainNotifications();
if (
this.closing ||
this.processFailed ||
active.cancelling ||
active.deferred !== deferred ||
deferred.timer !== null ||
this.hasDeferredBlockers()
) {
return;
}
this.finishDeferredTurn(active, { type: "complete", terminalizeTools: true });
}
private waitForInitialCommands(): Promise<void> {
if (this.receivedInitialCommands) return Promise.resolve();
const timeoutMs = this.options.options.acpOptions?.initialCommandsTimeoutMs ?? 1_000;
@@ -1421,9 +1918,10 @@ class AcpRuntime {
}
}
function routeVendorNotifications(
function routeIncomingMessages(
stream: Stream,
receive: (method: string, params: unknown) => void,
receiveVendor: (method: string, params: unknown) => void,
observeWire: (message: unknown) => void,
): Stream {
const clientMethods = new Set<string>(Object.values(CLIENT_METHODS));
return {
@@ -1435,11 +1933,14 @@ function routeVendorNotifications(
// The SDK dispatches extensions asynchronously and can resolve a later response first.
// Run synchronous vendor transforms in wire order, inside the configuration transaction.
try {
receive(message.method, message.params);
receiveVendor(message.method, message.params);
} catch (error) {
console.error("Error handling ACP vendor notification", error);
}
} else controller.enqueue(message);
} else {
observeWire(message);
controller.enqueue(message);
}
},
}),
),
@@ -1470,11 +1971,12 @@ function permissionOptionBehavior(
function ownConnectorStream(source: Stream): {
stream: Stream;
close(): Promise<void>;
close(options?: { force?: boolean; timeoutMs?: number }): Promise<void>;
whenClosed(): Promise<void> | null;
} {
const reader = source.readable.getReader();
const writer = source.writable.getWriter();
let closed = false;
let closing: Promise<void> | null = null;
const stream: Stream = {
readable: new ReadableStream({
async pull(controller) {
@@ -1496,13 +1998,29 @@ function ownConnectorStream(source: Stream): {
};
return {
stream,
async close() {
if (closed) return;
closed = true;
await Promise.allSettled([
reader.cancel(new Error("Paseo closed the ACP connector")),
writer.close(),
]);
whenClosed: () => closing,
async close(options?: { force?: boolean; timeoutMs?: number }) {
if (!closing) {
const closeWrite = options?.force
? writer.abort(new Error("Paseo aborted the ACP connector"))
: writer.close();
closing = Promise.allSettled([
reader.cancel(new Error("Paseo closed the ACP connector")),
closeWrite,
]).then((results) => {
if (options?.timeoutMs === undefined) return undefined;
const rejected = results.find(
(result): result is PromiseRejectedResult => result.status === "rejected",
);
if (rejected) throw rejected.reason;
return undefined;
});
}
if (options?.timeoutMs !== undefined) {
await withTimeout(closing, options.timeoutMs, "ACP connector did not close");
} else {
await closing.catch(() => undefined);
}
},
};
}
File diff suppressed because it is too large Load Diff
+12
View File
@@ -53,6 +53,18 @@ export interface AcpOptions {
initialCommandsTimeoutMs?: number;
/** Allow delayed session/load updates before publishing the session as ready. */
loadReplayQuietPeriodMs?: number;
/**
* Keep a turn open after `end_turn` while qualifying tool calls are still running,
* settling once those tools finish and the agent finishes its follow-up reply.
*/
deferTurnOnRunningTools?: {
/** Delay after `usage_update` closes a follow-up reply before settling. Defaults to 500ms. */
settleDelayMs?: number;
/** Quiet limit after qualifying tools finish if no reply settles via `usage_update`. Defaults to 120_000ms. */
quietLimitMs?: number;
/** Predicate deciding whether an open tool call keeps the turn open. Defaults to all running tools. */
keepsTurnOpen?: (toolCall: AcpToolCallSnapshot) => boolean;
};
/** An unattended mode that approves ACP allow-once requests in the specified native mode. */
autoAcceptMode?: {
mode: Omit<ProviderMode, "isUnattended">;
+2
View File
@@ -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;
+11
View File
@@ -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";
+6 -1
View File
@@ -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";
+69
View File
@@ -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>;
}
+1 -1
View File
@@ -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",
+136 -94
View File
@@ -881,6 +881,7 @@ export class AgentManager {
>();
private readonly collectingRuntimes = new Set<string>();
private readonly lifecycleMutationTails = new Map<string, Promise<void>>();
private readonly pendingCancellations = new Map<string, Promise<unknown>>();
private readonly agentStreamCoalescer: AgentStreamCoalescer;
private mcpBaseUrl: string | null;
private readonly mcpAuthToken: string | null;
@@ -2463,80 +2464,83 @@ export class AgentManager {
// reload or close; providers do no sequencing of their own.
async setAgentMode(agentId: string, modeId: string): Promise<AgentProviderNotice | null> {
return this.runLifecycleMutation(agentId, async () => {
const agent = await this.ensureInteractiveSessionUnlocked(agentId);
const notice = (await agent.session.setMode(modeId)) ?? null;
await this.drainSessionEvents(agentId);
const currentMode = (await agent.session.getCurrentMode()) ?? modeId;
agent.config.modeId = currentMode ?? undefined;
agent.currentModeId = currentMode;
// Update runtimeInfo to reflect the new mode
if (agent.runtimeInfo) {
agent.runtimeInfo = { ...agent.runtimeInfo, modeId: currentMode };
}
this.touchUpdatedAt(agent);
this.emitState(agent);
return notice;
});
return this.runLifecycleMutation(agentId, () =>
this.withLiveInteractiveSessionUnlocked(agentId, async (agent) => {
const notice = (await agent.session.setMode(modeId)) ?? null;
await this.drainSessionEvents(agentId);
const currentMode = (await agent.session.getCurrentMode()) ?? modeId;
agent.config.modeId = currentMode ?? undefined;
agent.currentModeId = currentMode;
// Update runtimeInfo to reflect the new mode
if (agent.runtimeInfo) {
agent.runtimeInfo = { ...agent.runtimeInfo, modeId: currentMode };
}
this.touchUpdatedAt(agent);
this.emitState(agent);
return notice;
}),
);
}
async setAgentModel(agentId: string, modelId: string | null): Promise<void> {
return this.runLifecycleMutation(agentId, async () => {
const agent = await this.ensureInteractiveSessionUnlocked(agentId);
const normalizedModelId =
typeof modelId === "string" && modelId.trim().length > 0 ? modelId : null;
return this.runLifecycleMutation(agentId, () =>
this.withLiveInteractiveSessionUnlocked(agentId, async (agent) => {
const normalizedModelId =
typeof modelId === "string" && modelId.trim().length > 0 ? modelId : null;
const selection = await agent.session.setModel?.(normalizedModelId);
await this.drainSessionEvents(agentId);
const selection = await agent.session.setModel?.(normalizedModelId);
await this.drainSessionEvents(agentId);
// A reset clears the preference even when the provider retains its active model.
let effectiveModelId = normalizedModelId;
if (normalizedModelId !== null && selection) effectiveModelId = selection.model;
// A reset clears the preference even when the provider retains its active model.
let effectiveModelId = normalizedModelId;
if (normalizedModelId !== null && selection) effectiveModelId = selection.model;
agent.config.model = effectiveModelId ?? undefined;
if (agent.runtimeInfo) {
agent.runtimeInfo = { ...agent.runtimeInfo, model: effectiveModelId };
}
this.refreshSessionPersistence(agent);
this.touchUpdatedAt(agent);
this.emitState(agent);
});
agent.config.model = effectiveModelId ?? undefined;
if (agent.runtimeInfo) {
agent.runtimeInfo = { ...agent.runtimeInfo, model: effectiveModelId };
}
this.refreshSessionPersistence(agent);
this.touchUpdatedAt(agent);
this.emitState(agent);
}),
);
}
async setAgentThinkingOption(
agentId: string,
thinkingOptionId: string | null,
): Promise<AgentProviderNotice | null> {
return this.runLifecycleMutation(agentId, async () => {
const agent = await this.ensureInteractiveSessionUnlocked(agentId);
const normalizedThinkingOptionId =
typeof thinkingOptionId === "string" && thinkingOptionId.trim().length > 0
? thinkingOptionId
: null;
return this.runLifecycleMutation(agentId, () =>
this.withLiveInteractiveSessionUnlocked(agentId, async (agent) => {
const normalizedThinkingOptionId =
typeof thinkingOptionId === "string" && thinkingOptionId.trim().length > 0
? thinkingOptionId
: null;
let notice: AgentProviderNotice | null = null;
if (agent.session.setThinkingOption) {
notice = (await agent.session.setThinkingOption(normalizedThinkingOptionId)) ?? null;
}
await this.drainSessionEvents(agentId);
let notice: AgentProviderNotice | null = null;
if (agent.session.setThinkingOption) {
notice = (await agent.session.setThinkingOption(normalizedThinkingOptionId)) ?? null;
}
await this.drainSessionEvents(agentId);
let effectiveThinkingOptionId = normalizedThinkingOptionId;
const runtimeInfo = await agent.session.getRuntimeInfo();
if (runtimeInfo.thinkingOptionId !== undefined) {
effectiveThinkingOptionId = runtimeInfo.thinkingOptionId;
}
let effectiveThinkingOptionId = normalizedThinkingOptionId;
const runtimeInfo = await agent.session.getRuntimeInfo();
if (runtimeInfo.thinkingOptionId !== undefined) {
effectiveThinkingOptionId = runtimeInfo.thinkingOptionId;
}
agent.config.thinkingOptionId = effectiveThinkingOptionId ?? undefined;
if (agent.runtimeInfo) {
agent.runtimeInfo = {
...agent.runtimeInfo,
thinkingOptionId: effectiveThinkingOptionId,
};
}
this.touchUpdatedAt(agent);
this.emitState(agent);
return notice;
});
agent.config.thinkingOptionId = effectiveThinkingOptionId ?? undefined;
if (agent.runtimeInfo) {
agent.runtimeInfo = {
...agent.runtimeInfo,
thinkingOptionId: effectiveThinkingOptionId,
};
}
this.touchUpdatedAt(agent);
this.emitState(agent);
return notice;
}),
);
}
/**
@@ -2546,42 +2550,45 @@ export class AgentManager {
* one step once the provider accepts. Patches to one agent run one at a time, in arrival order.
*/
async setAgentOptions(agentId: string, requested: ProviderOptionsPatch): Promise<void> {
return this.runLifecycleMutation(agentId, async () => {
const agent = await this.ensureInteractiveSessionUnlocked(agentId);
const patch = this.convertLegacyOptions(agent.provider, requested);
let ended: ProviderOptionsPatch = {};
let sent: ProviderOptionsPatch = {};
if (Object.keys(patch).length > 0) {
// A provider that cannot apply options to a running agent must not store them either.
if (!agent.session.applyOptions) {
throw new ProviderOptionsValidationError(
agent.provider,
Object.keys(patch).map((key) => ({
path: [key],
message: "cannot change on a running session; it applies when the agent is opened",
})),
return this.runLifecycleMutation(agentId, () =>
this.withLiveInteractiveSessionUnlocked(agentId, async (agent) => {
const patch = this.convertLegacyOptions(agent.provider, requested);
let ended: ProviderOptionsPatch = {};
let sent: ProviderOptionsPatch = {};
if (Object.keys(patch).length > 0) {
// A provider that cannot apply options to a running agent must not store them either.
if (!agent.session.applyOptions) {
throw new ProviderOptionsValidationError(
agent.provider,
Object.keys(patch).map((key) => ({
path: [key],
message: "cannot change on a running session; it applies when the agent is opened",
})),
);
}
const set = Object.fromEntries(
Object.entries(patch).filter(([, value]) => value != null),
);
const resolved = this.effectiveOptionsFor(agent.provider, set);
sent = Object.fromEntries(Object.keys(patch).map((key) => [key, resolved[key] ?? null]));
const modelBefore = agent.runtimeInfo?.model;
ended = (await agent.session.applyOptions(sent)) ?? {};
// Changes the provider made on its own while applying are older than its final answer.
await this.drainSessionEvents(agentId);
await this.refreshRuntimeInfo(agent, { emit: false });
// An option can choose the model too, as an fx connection does. Reopening the agent on
// the earlier preference would send that model to the new connection.
const modelAfter = agent.runtimeInfo?.model;
if (agent.config.model && modelAfter && modelAfter !== modelBefore) {
agent.config.model = modelAfter;
}
}
const set = Object.fromEntries(Object.entries(patch).filter(([, value]) => value != null));
const resolved = this.effectiveOptionsFor(agent.provider, set);
sent = Object.fromEntries(Object.keys(patch).map((key) => [key, resolved[key] ?? null]));
const modelBefore = agent.runtimeInfo?.model;
ended = (await agent.session.applyOptions(sent)) ?? {};
// Changes the provider made on its own while applying are older than its final answer.
await this.drainSessionEvents(agentId);
await this.refreshRuntimeInfo(agent, { emit: false });
// An option can choose the model too, as an fx connection does. Reopening the agent on
// the earlier preference would send that model to the new connection.
const modelAfter = agent.runtimeInfo?.model;
if (agent.config.model && modelAfter && modelAfter !== modelBefore) {
agent.config.model = modelAfter;
}
}
this.storeOptionsPatch({ agent, patch: { ...patch, ...ended } });
this.updateEffectiveOptions({ agent, sent, reported: ended });
this.touchUpdatedAt(agent);
this.emitState(agent);
});
this.storeOptionsPatch({ agent, patch: { ...patch, ...ended } });
this.updateEffectiveOptions({ agent, sent, reported: ended });
this.touchUpdatedAt(agent);
this.emitState(agent);
}),
);
}
/** The config as the opened session left it: its own difference from the options it was given. */
@@ -3267,6 +3274,33 @@ export class AgentManager {
return this.requireSessionAgent(agentId);
}
/** Inside the agent's lane: transparently reopens a retired plugin session before applying config. */
private async withLiveInteractiveSessionUnlocked<T>(
agentId: string,
operation: (agent: ActiveManagedAgent) => Promise<T>,
): Promise<T> {
const pendingCancellation = this.pendingCancellations.get(agentId);
if (pendingCancellation) {
await this.waitWithTimeout({
operation: pendingCancellation.then(
() => undefined,
() => undefined,
),
timeoutMs: this.rescueTimeouts.interruptSessionMs,
});
}
const agent = await this.ensureInteractiveSessionUnlocked(agentId);
try {
return await operation(agent);
} catch (error) {
if (!isStaleProviderSessionError(error)) throw error;
await this.runs.getPendingRun(agentId)?.settledPromise.catch(() => undefined);
if (this.hasInFlightRun(agentId)) throw error;
await this.trackAgentRegistrationOperation(this.reloadAgentSessionInternal(agentId));
return await operation(this.requireSessionAgent(agentId));
}
}
private async *streamAfterHistoryLoad(
agentId: string,
prompt: AgentPromptInput,
@@ -3925,10 +3959,18 @@ export class AgentManager {
}
async cancelAgentRun(agentId: string): Promise<AgentRunCancellationResult> {
return this.runForegroundMutation(agentId, () => {
const cancellation = this.runForegroundMutation(agentId, () => {
this.requireSessionAgent(agentId).pendingReplacement = false;
return this.cancelAgentRunNow(agentId);
});
this.pendingCancellations.set(agentId, cancellation);
try {
return await cancellation;
} finally {
if (this.pendingCancellations.get(agentId) === cancellation) {
this.pendingCancellations.delete(agentId);
}
}
}
private async cancelAgentRunNow(agentId: string): Promise<AgentRunCancellationResult> {
@@ -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,
@@ -6,6 +6,7 @@ import { createIdleRuntimeCleanup } from "./idle-runtime-cleanup/index.js";
import { relative } from "node:path";
import { execFileSync } from "node:child_process";
import { fileURLToPath } from "node:url";
import { runAcpProvider, type AcpStreamMessage } from "@getpaseo/plugin/server/acp";
import type {
ProviderConnection,
ProviderLaunch,
@@ -13,6 +14,7 @@ import type {
ProviderInput,
ProviderRegistration,
} from "@getpaseo/plugin/server/provider";
import { sendPreparedPromptToAgent } from "./agent-prompt.js";
import { setImmediate as nextTurn } from "node:timers/promises";
import { describe, expect, test } from "vitest";
import { createTestLogger } from "../../test-utils/test-logger.js";
@@ -2814,3 +2816,592 @@ test("resumes a goose session saved by the generic ACP provider", async () => {
await plugins.shutdown();
}
});
test("preserves a deferred ACP background job on steer and cancels it on explicit Stop through AgentManager", async () => {
const logger = createTestLogger();
const home = await mkdtemp(join(tmpdir(), "paseo-acp-deferred-daemon-"));
const storage = new AgentStorage(join(home, "agents"), logger);
let cancelCount = 0;
let promptCount = 0;
let currentMode = "default";
let notifyAgent: ((message: AcpStreamMessage) => void) | null = null;
let holdNextPrompt: ((release: () => void) => void) | null = null;
const modeConfig = () => [
{
id: "mode",
name: "Mode",
category: "mode",
type: "select",
currentValue: currentMode,
options: [
{ value: "default", name: "Default" },
{ value: "plan", name: "Plan" },
],
},
];
const registration = runAcpProvider({
id: "deferred-acp-daemon",
label: "Deferred ACP Daemon",
acpOptions: {
deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 1_000 },
},
connector() {
let controller!: ReadableStreamDefaultController<AcpStreamMessage>;
const readable = new ReadableStream<AcpStreamMessage>({
start(ctrl) {
controller = ctrl;
},
});
const send = (message: AcpStreamMessage) => controller.enqueue(message);
notifyAgent = send;
const writable = new WritableStream<AcpStreamMessage>({
write(message) {
if (!("method" in message)) return;
if (message.method === "session/cancel") {
cancelCount += 1;
return;
}
if (!("id" in message)) return;
if (message.method === "initialize") {
send({
jsonrpc: "2.0",
id: message.id,
result: { protocolVersion: 1, agentCapabilities: { loadSession: true } },
});
return;
}
if (message.method === "session/new") {
send({
jsonrpc: "2.0",
id: message.id,
result: { sessionId: "acp-s1", configOptions: modeConfig() },
});
return;
}
if (message.method === "session/load") {
send({ jsonrpc: "2.0", id: message.id, result: { configOptions: modeConfig() } });
return;
}
if (message.method === "session/set_config_option") {
const params = message.params as { value?: string } | undefined;
if (typeof params?.value === "string") currentMode = params.value;
send({ jsonrpc: "2.0", id: message.id, result: { configOptions: modeConfig() } });
return;
}
if (message.method === "session/prompt") {
promptCount += 1;
if (promptCount === 1) {
send({
jsonrpc: "2.0",
method: "session/update",
params: {
sessionId: "acp-s1",
update: {
sessionUpdate: "tool_call",
toolCallId: "bg-job-1",
name: "run_command",
title: "Background job",
status: "in_progress",
},
},
});
} else if (promptCount === 2) {
send({
jsonrpc: "2.0",
method: "session/update",
params: {
sessionId: "acp-s1",
update: {
sessionUpdate: "agent_message_chunk",
content: { type: "text", text: "Steered reply" },
},
},
});
} else {
send({
jsonrpc: "2.0",
method: "session/update",
params: {
sessionId: "acp-s1",
update: {
sessionUpdate: "tool_call",
toolCallId: "bg-job-2",
name: "run_command",
title: "Cancelable job",
status: "in_progress",
},
},
});
}
if (holdNextPrompt) {
const hook = holdNextPrompt;
holdNextPrompt = null;
hook(() =>
send({ jsonrpc: "2.0", id: message.id, result: { stopReason: "cancelled" } }),
);
return;
}
send({ jsonrpc: "2.0", id: message.id, result: { stopReason: "end_turn" } });
return;
}
if (message.method === "session/close") {
send({ jsonrpc: "2.0", id: message.id, result: {} });
}
},
});
return { readable, writable };
},
});
const plugins = new PluginAgentClientRegistry(logger);
plugins.replace([registration]);
const manager = new AgentManager({ clients: plugins.clients(), registry: storage, logger });
try {
const agent = await manager.createAgent({ provider: registration.id, cwd: home }, undefined, {
workspaceId: undefined,
});
const first = await sendPreparedPromptToAgent({
agentManager: manager,
agentStorage: storage,
agentId: agent.id,
prompt: "start background job",
logger,
});
expect(first.disposition).toBe("turn_started");
if (first.disposition === "turn_started") await first.started;
await new Promise((resolve) => setTimeout(resolve, 40));
expect(manager.getAgent(agent.id)?.lifecycle).toBe("running");
// Follow-up steer through AgentManager preserves the background job without session/cancel.
const followUp = await sendPreparedPromptToAgent({
agentManager: manager,
agentStorage: storage,
agentId: agent.id,
prompt: "still working?",
activeTurnBehavior: "steer",
logger,
});
expect(followUp.disposition).toBe("steered");
expect(cancelCount).toBe(0);
await new Promise((resolve) => setTimeout(resolve, 40));
expect(manager.getAgent(agent.id)?.lifecycle).toBe("running");
// Completing the job + reply + usage_update settles the turn cleanly.
notifyAgent!({
jsonrpc: "2.0",
method: "session/update",
params: {
sessionId: "acp-s1",
update: { sessionUpdate: "tool_call_update", toolCallId: "bg-job-1", status: "completed" },
},
});
notifyAgent!({
jsonrpc: "2.0",
method: "session/update",
params: {
sessionId: "acp-s1",
update: {
sessionUpdate: "agent_message_chunk",
content: { type: "text", text: "Background job finished." },
},
},
});
notifyAgent!({
jsonrpc: "2.0",
method: "session/update",
params: {
sessionId: "acp-s1",
update: { sessionUpdate: "usage_update", used: 120, size: 1000 },
},
});
await expect.poll(() => manager.getAgent(agent.id)?.lifecycle, { timeout: 3_000 }).toBe("idle");
expect(cancelCount).toBe(0);
// Start a second deferred job, send two steers while steer 1 waits on ACP, and press Stop.
let heldSteerResponse: (() => void) | null = null;
const second = await sendPreparedPromptToAgent({
agentManager: manager,
agentStorage: storage,
agentId: agent.id,
prompt: "start cancelable job",
logger,
});
if (second.disposition === "turn_started") await second.started;
await new Promise((resolve) => setTimeout(resolve, 40));
expect(manager.getAgent(agent.id)?.lifecycle).toBe("running");
// Hold the next steer prompt so Stop races with a queued second steer.
holdNextPrompt = (release) => {
heldSteerResponse = release;
};
const steerOne = await sendPreparedPromptToAgent({
agentManager: manager,
agentStorage: storage,
agentId: agent.id,
prompt: "held steer 1",
activeTurnBehavior: "steer",
logger,
});
expect(steerOne.disposition).toBe("steered");
const steerTwo = await sendPreparedPromptToAgent({
agentManager: manager,
agentStorage: storage,
agentId: agent.id,
prompt: "queued steer 2",
activeTurnBehavior: "steer",
logger,
});
expect(steerTwo.disposition).toBe("steered");
await expect.poll(() => heldSteerResponse).not.toBeNull();
const promptsBeforeStop = promptCount;
// Stop must send session/cancel immediately, retire the deferred session cleanly,
// and never dispatch the queued steer 2 to ACP.
await manager.cancelAgentRun(agent.id);
expect(cancelCount).toBe(1);
await expect.poll(() => manager.getAgent(agent.id)?.lifecycle, { timeout: 3_000 }).toBe("idle");
expect(promptCount).toBe(promptsBeforeStop);
// Changing mode immediately after stopping a deferred turn must transparently reopen the session.
await manager.setAgentMode(agent.id, "plan");
expect(manager.getAgent(agent.id)?.currentModeId).toBe("plan");
expect(currentMode).toBe("plan");
} finally {
await Promise.all(manager.listAgents().map((item) => manager.closeAgent(item.id)));
await plugins.shutdown();
await storage.flush();
await rm(home, { recursive: true, force: true });
}
});
test("reopens cleanly for mode changes and follow-up sends initiated while Stop is closing a slow ACP process", async () => {
const logger = createTestLogger();
const home = await mkdtemp(join(tmpdir(), "paseo-acp-slow-stop-"));
const storage = new AgentStorage(join(home, "agents"), logger);
const script = join(home, "slow-stop-agent.cjs");
const { writeFile } = await import("node:fs/promises");
await writeFile(
script,
`
const { createInterface } = require("node:readline");
const send = (msg) => process.stdout.write(JSON.stringify({ jsonrpc: "2.0", ...msg }) + "\\n");
let mode = "default";
const configOptions = () => [{
id: "mode", name: "Mode", category: "mode", type: "select", currentValue: mode,
options: [{ value: "default", name: "Default" }, { value: "plan", name: "Plan" }],
}];
process.on("SIGTERM", () => {
setTimeout(() => process.exit(0), 250);
});
createInterface({ input: process.stdin }).on("line", (line) => {
const msg = JSON.parse(line);
if (msg.method === "initialize") {
send({ id: msg.id, result: { protocolVersion: 1, agentCapabilities: { loadSession: true } } });
} else if (msg.method === "session/new") {
send({ id: msg.id, result: { sessionId: "slow-s1", configOptions: configOptions() } });
} else if (msg.method === "session/load") {
send({ id: msg.id, result: { configOptions: configOptions() } });
} else if (msg.method === "session/set_config_option") {
if (msg.params && typeof msg.params.value === "string") mode = msg.params.value;
send({ id: msg.id, result: { configOptions: configOptions() } });
} else if (msg.method === "session/prompt") {
const text = msg.params?.prompt?.[0]?.text ?? "";
if (text.includes("start bg")) {
send({ method: "session/update", params: { sessionId: "slow-s1", update: {
sessionUpdate: "tool_call", toolCallId: "slow-bg-1", name: "run_command",
title: "Slow bg job", status: "in_progress",
} } });
} else {
send({ method: "session/update", params: { sessionId: "slow-s1", update: {
sessionUpdate: "agent_message_chunk", content: { type: "text", text: "After stop reply" },
} } });
}
send({ id: msg.id, result: { stopReason: "end_turn" } });
} else if (msg.method === "session/close") {
send({ id: msg.id, result: {} });
}
});
`,
);
const registration = runAcpProvider({
id: "slow-stop-acp",
label: "Slow Stop ACP",
command: [process.execPath, script],
acpOptions: {
deferTurnOnRunningTools: { settleDelayMs: 25, quietLimitMs: 1_000 },
},
});
const plugins = new PluginAgentClientRegistry(logger);
plugins.replace([registration]);
const manager = new AgentManager({ clients: plugins.clients(), registry: storage, logger });
try {
const agent = await manager.createAgent({ provider: registration.id, cwd: home }, undefined, {
workspaceId: undefined,
});
const first = await sendPreparedPromptToAgent({
agentManager: manager,
agentStorage: storage,
agentId: agent.id,
prompt: "start bg",
logger,
});
if (first.disposition === "turn_started") await first.started;
await new Promise((resolve) => setTimeout(resolve, 40));
expect(manager.getAgent(agent.id)?.lifecycle).toBe("running");
// Start Stop (takes 250ms to terminate the child on SIGTERM) and trigger a mode change mid-shutdown.
const stopPromise = manager.cancelAgentRun(agent.id);
await new Promise((resolve) => setTimeout(resolve, 50));
const modePromise = manager.setAgentMode(agent.id, "plan");
await Promise.all([stopPromise, modePromise]);
expect(manager.getAgent(agent.id)?.currentModeId).toBe("plan");
expect(manager.getAgent(agent.id)?.lifecycle).toBe("idle");
// A follow-up prompt immediately after Stop + mode change succeeds cleanly.
const next = await sendPreparedPromptToAgent({
agentManager: manager,
agentStorage: storage,
agentId: agent.id,
prompt: "fresh prompt",
logger,
});
expect(next.disposition).toBe("turn_started");
if (next.disposition === "turn_started") await next.started;
await expect.poll(() => manager.getAgent(agent.id)?.lifecycle, { timeout: 3_000 }).toBe("idle");
} finally {
await Promise.all(manager.listAgents().map((item) => manager.closeAgent(item.id)));
await plugins.shutdown();
await storage.flush();
await rm(home, { recursive: true, force: true });
}
});
test("does not block mode changes after a plugin refuses Stop by ignoring session.interrupt", async () => {
const logger = createTestLogger();
let currentMode = "code";
const harness = createProviderHarness({
async handleInput(input, emit) {
if (input.type === "session.open") {
emit({
type: "session.opened",
requestId: input.requestId,
sessionId: input.sessionId,
capabilities: ["prompt.message", "session.interrupt", "session.configure"],
restoration: "core",
title: input.config.title,
cwd: input.config.cwd,
});
emit({
type: "session.config",
sessionId: input.sessionId,
config: {
mode: currentMode,
modes: [
{ id: "code", label: "Code" },
{ id: "plan", label: "Plan" },
],
models: [],
thinkingOptions: [],
},
});
emit({ type: "session.ready", requestId: input.requestId, sessionId: input.sessionId });
return true;
}
if (input.type === "session.prompt") {
emit({
type: "session.prompt_result",
sessionId: input.sessionId,
clientMessageId: input.prompt.clientMessageId,
result: { type: "turn", turnId: "hung-turn" },
});
emit({
type: "session.turn",
sessionId: input.sessionId,
turnId: "hung-turn",
state: "started",
});
return true;
}
if (input.type === "session.interrupt") {
// Intentionally never acknowledge session.interrupt.
return true;
}
if (input.type === "session.configure") {
if (input.changes.mode) currentMode = input.changes.mode;
emit({
type: "session.config",
sessionId: input.sessionId,
config: {
mode: currentMode,
modes: [
{ id: "code", label: "Code" },
{ id: "plan", label: "Plan" },
],
models: [],
thinkingOptions: [],
},
});
emit({ type: "request.completed", requestId: input.requestId });
return true;
}
return false;
},
});
const plugins = new PluginAgentClientRegistry(logger);
plugins.replace([harness.registration]);
const registry = buildProviderRegistry(logger, { pluginProviders: plugins.definitions() });
const manager = new AgentManager({
logger,
clients: { "plugin-direct": registry["plugin-direct"].createClient(logger) },
providerDefinitions: { "plugin-direct": registry["plugin-direct"] },
rescueTimeouts: { interruptSessionMs: 50 },
});
try {
const agent = await manager.createAgent(
{ provider: "plugin-direct", cwd: tmpdir() },
undefined,
{ workspaceId: undefined },
);
const stream = manager.streamAgent(agent.id, "start");
void stream.next();
await expect
.poll(() => manager.getAgent(agent.id)?.lifecycle, { timeout: 2_000 })
.toBe("running");
const cancelResult = await manager.cancelAgentRun(agent.id);
expect(cancelResult.status).toBe("refused");
// Settings change must not hang behind the unacknowledged session.interrupt.
await manager.setAgentMode(agent.id, "plan");
expect(manager.getAgent(agent.id)?.currentModeId).toBe("plan");
} finally {
await Promise.all(manager.listAgents().map((item) => manager.closeAgent(item.id)));
await plugins.shutdown();
}
});
test("bounds settings wait when Stop is queued behind an unanswered steer", async () => {
const logger = createTestLogger();
let currentMode = "code";
let releaseSteer: (() => void) | null = null;
const harness = createProviderHarness({
capabilities: ["prompt.message", "prompt.steer", "session.interrupt", "session.configure"],
async handleInput(input, emit) {
if (input.type === "session.open") {
emit({
type: "session.opened",
requestId: input.requestId,
sessionId: input.sessionId,
capabilities: [
"prompt.message",
"prompt.steer",
"session.interrupt",
"session.configure",
],
restoration: "core",
title: input.config.title,
cwd: input.config.cwd,
});
emit({
type: "session.config",
sessionId: input.sessionId,
config: {
mode: currentMode,
modes: [
{ id: "code", label: "Code" },
{ id: "plan", label: "Plan" },
],
models: [],
thinkingOptions: [],
},
});
emit({ type: "session.ready", requestId: input.requestId, sessionId: input.sessionId });
return true;
}
if (input.type === "session.prompt") {
if (input.prompt.delivery === "steer") {
releaseSteer = () =>
emit({
type: "session.prompt_result",
sessionId: input.sessionId,
clientMessageId: input.prompt.clientMessageId,
result: { type: "steer", turnId: "steer-turn" },
});
return true;
}
emit({
type: "session.prompt_result",
sessionId: input.sessionId,
clientMessageId: input.prompt.clientMessageId,
result: { type: "turn", turnId: "steer-turn" },
});
emit({
type: "session.turn",
sessionId: input.sessionId,
turnId: "steer-turn",
state: "started",
});
return true;
}
if (input.type === "session.interrupt") {
return true;
}
if (input.type === "session.configure") {
if (input.changes.mode) currentMode = input.changes.mode;
emit({
type: "session.config",
sessionId: input.sessionId,
config: {
mode: currentMode,
modes: [
{ id: "code", label: "Code" },
{ id: "plan", label: "Plan" },
],
models: [],
thinkingOptions: [],
},
});
emit({ type: "request.completed", requestId: input.requestId });
return true;
}
return false;
},
});
const plugins = new PluginAgentClientRegistry(logger);
plugins.replace([harness.registration]);
const registry = buildProviderRegistry(logger, { pluginProviders: plugins.definitions() });
const manager = new AgentManager({
logger,
clients: { "plugin-direct": registry["plugin-direct"].createClient(logger) },
providerDefinitions: { "plugin-direct": registry["plugin-direct"] },
rescueTimeouts: { interruptSessionMs: 50 },
});
try {
const agent = await manager.createAgent(
{ provider: "plugin-direct", cwd: tmpdir() },
undefined,
{ workspaceId: undefined },
);
const stream = manager.streamAgent(agent.id, "start");
void stream.next();
await expect
.poll(() => manager.getAgent(agent.id)?.lifecycle, { timeout: 2_000 })
.toBe("running");
// Start an unanswered steer, queue Stop behind it, then change mode.
const steerPromise = manager.steerAgentRun(agent.id, "unanswered steer").catch(() => undefined);
await new Promise((resolve) => setTimeout(resolve, 20));
const stopPromise = manager.cancelAgentRun(agent.id);
await new Promise((resolve) => setTimeout(resolve, 10));
// Mode change must complete within the bounded interrupt timeout even while Stop is queued.
await manager.setAgentMode(agent.id, "plan");
expect(manager.getAgent(agent.id)?.currentModeId).toBe("plan");
releaseSteer?.();
await Promise.all([steerPromise, stopPromise]);
} finally {
releaseSteer?.();
await Promise.all(manager.listAgents().map((item) => manager.closeAgent(item.id)));
await plugins.shutdown();
}
});
@@ -739,6 +739,7 @@ class ProviderRuntimeSession {
}
async configure(changes: ProviderConfigChanges): Promise<void> {
if (this.terminal) throw new StaleProviderSessionError(this.id);
const input: Extract<ProviderInput, { type: "session.configure" }> = {
type: "session.configure",
requestId: randomUUID(),
@@ -99,6 +99,74 @@ describe("ClaudeAgentSession persisted history load", () => {
rmSync(tempRoot, { recursive: true, force: true });
});
test("resumes many records within a chunk-sized event-loop turn budget", async () => {
const count = 3_072;
const text = "🙂".repeat(128);
const entries = Array.from({ length: count }, (_, index) =>
JSON.stringify({ type: "assistant", message: { content: `${index}:${text}` } }),
);
entries.splice(count / 2, 0, JSON.stringify({ type: "system", subtype: "compact_boundary" }));
mkdirSync(path.dirname(transcriptPath()), { recursive: true });
writeFileSync(transcriptPath(), entries.join("\n"));
let turns = 0;
let ticker: NodeJS.Immediate;
function tick() {
turns++;
const deadline = performance.now() + 2;
while (performance.now() < deadline) {}
ticker = setImmediate(tick);
}
ticker = setImmediate(tick);
const session = await resume().finally(() => clearImmediate(ticker));
try {
const messages = [];
for await (const event of session.streamHistory()) {
if (event.type === "timeline" && event.item.type === "assistant_message") {
messages.push(event.item.text);
}
}
expect(messages).toEqual(Array.from({ length: count }, (_, index) => `${index}:${text}`));
expect(turns).toBeLessThan(count);
} finally {
await session.close();
}
}, 30_000);
test("yields during replay of a dense window with an expensive consumer", async () => {
const file = transcriptPath();
const count = 500;
const record = JSON.stringify({ type: "assistant", message: { content: "saved reply" } });
mkdirSync(path.dirname(file), { recursive: true });
writeFileSync(file, (record + "\n").repeat(count));
await withClaudeReplayHistory(file, async (history) => {
let turns = 0;
let ticker: NodeJS.Immediate | undefined;
function tick() {
turns++;
ticker = setImmediate(tick);
}
let entries = 0;
try {
for await (const _entry of history.parentEntries) {
// Start counting after the read so only yields within the window count.
ticker ??= setImmediate(tick);
const deadline = performance.now() + 1;
while (performance.now() < deadline) {}
entries++;
}
} finally {
if (ticker) clearImmediate(ticker);
}
expect(entries).toBe(count);
expect(turns).toBeGreaterThanOrEqual(20);
});
});
test("serves unrelated health requests while resuming 32 MiB of ordered history", async () => {
const startedAt = performance.now();
mkdirSync(path.dirname(transcriptPath()), { recursive: true });
@@ -700,6 +768,75 @@ describe("ClaudeAgentSession persisted history load", () => {
},
);
test.each(["return", "throw"])(
"replays oversized records and closes every source after callback %s",
async (exit) => {
const parent = transcriptPath();
const directory = path.join(parent.slice(0, -".jsonl".length), "subagents");
const child = path.join(directory, "agent-child.jsonl");
const workflow = path.join(directory, "workflows", "wf_test", "agent-child.jsonl");
const notification = {
type: "system",
subtype: "task_notification",
task_id: "task-id",
status: "completed",
};
const result = {
type: "user",
message: {
content: [
{ type: "tool_result", tool_use_id: "tool-id", content: "é".repeat(600 * 1024) },
],
},
};
const parentRecords = [notification, result, notification];
const childRecords = parentRecords.map((entry) => ({
...entry,
isSidechain: true,
agentId: "child",
}));
mkdirSync(path.dirname(workflow), { recursive: true });
writeFileSync(parent, parentRecords.map((entry) => JSON.stringify(entry)).join("\n"));
writeFileSync(child, childRecords.map((entry) => JSON.stringify(entry)).join("\n"));
writeFileSync(workflow, childRecords.map((entry) => JSON.stringify(entry)).join("\n"));
const sources: AsyncIterable<unknown>[] = [];
const failure = new Error("consumer failed");
const replay = withClaudeReplayHistory(parent, async (history) => {
const parentEntries = await Array.fromAsync(history.parentEntries);
const firstId = expect.stringMatching(/^task_notification_.*_1$/);
const secondId = expect.stringMatching(/^task_notification_.*_2$/);
expect(parentEntries).toEqual([
{ ...notification, notificationId: firstId },
result,
{ ...notification, notificationId: secondId },
]);
const [first, , last] = parentEntries;
const childEntries = history.subagents[0]!.entries;
const workflowEntries = history.workflowEntriesByRunId.get("wf_test")!;
sources.push(history.parentEntries, childEntries, workflowEntries);
const expectedChildEntries = [
{ ...childRecords[0], notificationId: first!.notificationId },
childRecords[1],
{ ...childRecords[2], notificationId: last!.notificationId },
];
expect(await Array.fromAsync(childEntries)).toEqual(expectedChildEntries);
expect(await Array.fromAsync(workflowEntries)).toEqual(expectedChildEntries);
expect(await Array.fromAsync(history.parentEntries)).toEqual(parentEntries);
if (exit === "throw") throw failure;
});
if (exit === "throw") await expect(replay).rejects.toBe(failure);
else await replay;
// Reading again probes whether replay released each descriptor when the callback ended.
for (const source of sources) {
await expect(source[Symbol.asyncIterator]().next()).rejects.toMatchObject({
code: "EBADF",
});
}
},
);
// chmod does not remove read access on Windows, or for root.
test.skipIf(process.platform === "win32" || process.getuid?.() === 0)(
"logs a warning with the error when Claude's project folders cannot be listed",
@@ -878,11 +878,12 @@ describe("ClaudeAgentSession persisted subagent replay", () => {
const text = "é🙂".repeat(30_000);
const historyDir = claudeProjectDirSync(cwd, { configDir });
mkdirSync(historyDir, { recursive: true });
const first = parentEntry([{ type: "text", text }]);
// Put the first byte of é at the end of a 1 MiB read.
const padding = " ".repeat(1024 * 1024 - 1 - first.indexOf(text));
writeFileSync(
path.join(historyDir, "replay-session.jsonl"),
parentEntry([{ type: "text", text }]) +
"\r\nnot json\r\n" +
parentEntry([{ type: "text", text: "final row" }]),
padding + first + "\r\nnot json\r\n" + parentEntry([{ type: "text", text: "final row" }]),
);
const events = await replayEvents();
expect(events.filter((event) => event.type === "timeline").map((event) => event.item)).toEqual([
@@ -41,6 +41,34 @@ function parentEntries(
}
describe("Claude workflow replay", () => {
it("skips parent history when there are no workflow summaries", async () => {
const entries = {
[Symbol.iterator](): Iterator<ClaudeWorkflowParentEntry> {
throw new Error("parent history must not be read");
},
};
await expect(
observeReplayWorkflows({ workflows: [], parentEntries: entries }),
).resolves.toEqual([]);
});
it("links workflow results from a single traversal, including results before their calls", async () => {
const [call, result] = parentEntries();
const entries = (async function* () {
yield result!;
yield call!;
})();
const observations = await observeReplayWorkflows({
workflows: [{ runId: RUN_ID, status: "completed" }],
parentEntries: entries,
});
expect(observations).toEqual([
{ kind: "declared", id: TOOL_CALL_ID, toolCallId: TOOL_CALL_ID, title: "Workflow" },
{ kind: "subtitle", id: TOOL_CALL_ID, subtitle: "Workflow" },
{ kind: "status", id: TOOL_CALL_ID, status: "completed" },
]);
});
it("parses the persisted run summary observed from Claude Code 2.1.220", async () => {
expect(
parseClaudeWorkflowRun(
@@ -55,7 +55,9 @@ export async function observeReplayWorkflows(input: {
>;
convertEntry?: (entry: ClaudeReplayEntry) => AgentTimelineItem[] | Promise<AgentTimelineItem[]>;
}): Promise<SubagentObservation[]> {
const toolCallIdByRunId = await readWorkflowLinks(input.parentEntries);
if (input.workflows.length === 0) return [];
const runIds = new Set(input.workflows.map((workflow) => workflow.runId));
const toolCallIdByRunId = await readWorkflowLinks(input.parentEntries, runIds);
const observations: SubagentObservation[] = [];
for (const workflow of input.workflows) {
@@ -155,34 +157,33 @@ async function observeWorkflowTimeline(input: {
async function readWorkflowLinks(
entries: Iterable<ClaudeWorkflowParentEntry> | AsyncIterable<ClaudeWorkflowParentEntry>,
runIds: ReadonlySet<string>,
): Promise<Map<string, string>> {
const workflowToolCallIds = new Set<string>();
const toolCallIdByRunId = new Map<string, string>();
for await (const entry of entries) {
const content = entry.message?.content;
if (!Array.isArray(content)) continue;
for (const value of content) {
const block = toRecord(value);
if (block?.type !== "tool_use" || block.name !== "Workflow") continue;
const id = readString(block.id);
if (id) workflowToolCallIds.add(id);
}
}
const results: { runId: string; toolCallId: string }[] = [];
for await (const entry of entries) {
const content = entry.message?.content;
if (!Array.isArray(content)) continue;
for (const value of content) {
const block = toRecord(value);
if (block?.type === "tool_use" && block.name === "Workflow") {
const id = readString(block.id);
if (id) workflowToolCallIds.add(id);
}
if (block?.type !== "tool_result") continue;
const toolCallId = readString(block.tool_use_id);
if (!toolCallId || !workflowToolCallIds.has(toolCallId)) continue;
if (!toolCallId) continue;
const runId = readRunId(block.content);
if (runId) toolCallIdByRunId.set(runId, toolCallId);
if (runId && runIds.has(runId)) results.push({ runId, toolCallId });
}
}
// Resolve IDs in result order after all calls are known, even if a result precedes its call.
const toolCallIdByRunId = new Map<string, string>();
for (const { runId, toolCallId } of results) {
if (workflowToolCallIds.has(toolCallId)) toolCallIdByRunId.set(runId, toolCallId);
}
return toolCallIdByRunId;
}
@@ -13,6 +13,10 @@ import {
type ClaudeWorkflowRun,
} from "./subagents/workflow-replay-source.js";
const READ_CHUNK_BYTES = 1024 * 1024;
// Async iteration between reads uses microtasks, including work inside the consumer.
const REPLAY_SLICE_MS = 10;
interface TranscriptEntry extends ClaudeReplayEntry {
isSidechain?: unknown;
}
@@ -43,13 +47,18 @@ async function* locatedRecords(
let pieces: Buffer[] = [];
let length = 0;
while (remaining > 0) {
const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, remaining));
const buffer = Buffer.allocUnsafe(Math.min(READ_CHUNK_BYTES, remaining));
const { bytesRead: count } = await fd.read(buffer, 0, buffer.length, null);
if (count === 0) break;
remaining -= count;
let sliceStartedAt = performance.now();
let start = 0;
let end: number;
while ((end = buffer.indexOf(10, start)) !== -1 && end < count) {
if (performance.now() - sliceStartedAt >= REPLAY_SLICE_MS) {
await setImmediate();
sliceStartedAt = performance.now();
}
pieces.push(buffer.subarray(start, end));
length += end - start;
const entry = parseRecord(Buffer.concat(pieces, length).toString("utf8"));
@@ -65,8 +74,6 @@ async function* locatedRecords(
if (entry) yield { entry, location };
start = end + 1;
}
// Bound parsing work as well as IO; microtasks alone do not service timers or sockets.
await setImmediate();
if (start < count) {
pieces.push(buffer.subarray(start, count));
length += count - start;
@@ -96,27 +103,52 @@ function indexedRecords(
},
};
async function* readEntries(): AsyncGenerator<TranscriptEntry> {
const chunk = Buffer.allocUnsafe(READ_CHUNK_BYTES);
let window: { file: string; offset: number; bytes: Buffer } | undefined;
let sliceStartedAt = performance.now();
for (const location of locations) {
const fd = descriptors.get(location.file)!;
const buffer = Buffer.allocUnsafe(location.length);
let read = 0;
while (read < buffer.length) {
const { bytesRead: count } = await fd.read(
buffer,
read,
buffer.length - read,
location.offset + read,
);
if (count === 0)
throw new Error(`Claude transcript was truncated during replay: ${location.file}`);
read += count;
if (
window?.file !== location.file ||
location.offset < window.offset ||
location.offset + location.length > window.offset + window.bytes.length
) {
const fd = descriptors.get(location.file)!;
const buffer = location.length > chunk.length ? Buffer.allocUnsafe(location.length) : chunk;
// Read ahead from the next indexed record. The index still owns selection and order,
// including sparse sidechains and workflow records sorted across files.
window = {
file: location.file,
offset: location.offset,
bytes: await readRecordWindow(fd, buffer, location),
};
sliceStartedAt = performance.now();
}
const entry = parseRecord(buffer.toString("utf8"));
if (performance.now() - sliceStartedAt >= REPLAY_SLICE_MS) {
await setImmediate();
sliceStartedAt = performance.now();
}
const start = location.offset - window.offset;
const entry = parseRecord(window.bytes.toString("utf8", start, start + location.length));
if (entry) yield entry;
}
}
}
async function readRecordWindow(
fd: FileHandle,
buffer: Buffer,
location: RecordLocation,
): Promise<Buffer> {
let read = 0;
while (read < location.length) {
const { bytesRead } = await fd.read(buffer, read, buffer.length - read, location.offset + read);
if (bytesRead === 0)
throw new Error(`Claude transcript was truncated during replay: ${location.file}`);
read += bytesRead;
}
return buffer.subarray(0, read);
}
function isToolResult(entry: TranscriptEntry): boolean {
return (
Array.isArray(entry.message?.content) &&
@@ -1,4 +1,13 @@
import { existsSync, rmSync, statSync } from "node:fs";
import {
existsSync,
mkdtempSync,
readFileSync,
rmSync,
statSync,
symlinkSync,
writeFileSync,
} from "node:fs";
import os from "node:os";
import path from "node:path";
import { describe, expect, test } from "vitest";
@@ -22,3 +31,30 @@ describe.skipIf(process.platform === "win32")("materializeProviderImage", () =>
}
});
});
test.skipIf(process.platform === "win32")(
"replaces a cached attachment directory turned into a symlink",
async () => {
const image = { data: "c3ltbGluayByZWdyZXNzaW9u", mimeType: "image/png" };
const first = await materializeProviderImage(image);
const dir = path.dirname(first.path);
const target = mkdtempSync(path.join(os.tmpdir(), "paseo-image-symlink-test-"));
let replacement: string | undefined;
try {
rmSync(dir, { recursive: true });
// Populate the target to exercise validation before accepting a cache hit.
writeFileSync(path.join(target, path.basename(first.path)), "symlink target");
symlinkSync(target, dir, "dir");
const second = await materializeProviderImage(image);
replacement = path.dirname(second.path);
expect(replacement).not.toBe(dir);
expect(path.basename(replacement)).toMatch(/^paseo-attachments-/);
expect(readFileSync(second.path, "utf8")).toBe("symlink regression");
} finally {
if (replacement && replacement !== dir) rmSync(replacement, { recursive: true });
rmSync(dir, { recursive: true, force: true });
rmSync(target, { recursive: true, force: true });
}
},
);
@@ -1,3 +1,4 @@
import { AsyncLocalStorage, createHook } from "node:async_hooks";
import { existsSync, rmSync, statSync, readFileSync } from "node:fs";
import path from "node:path";
import MarkdownIt from "markdown-it";
@@ -211,7 +212,7 @@ test("64 MiB materialization leaves the event loop responsive and preserves byte
});
test("preserves base64 decoding across whitespace and chunk boundaries", async () => {
const bytes = Buffer.alloc(512 * 1024, 123);
const bytes = Buffer.alloc(1024 * 1024, 123);
const base64 = bytes.toString("base64");
const data = base64.match(/.{1,77}/g)!.join("\n");
const result = await materializeProviderImage({ data, mimeType: "image/png" });
@@ -247,3 +248,114 @@ test("simultaneous requests for the same content share the published file", asyn
expect(results[0]).toEqual(results[1]);
expect(readFileSync(results[0].path).toString()).toBe("concurrent dedupe fixture");
});
test("a small image finishes before an earlier distinct 64 MiB image", async () => {
const largeData = Buffer.alloc(64 * 1024 * 1024, 42).toString("base64");
const smallData = Buffer.from("live image during large replay").toString("base64");
const completionOrder: string[] = [];
const large = materializeProviderImage({ data: largeData, mimeType: "image/png" }).then(
(image) => {
completionOrder.push("large");
return image;
},
);
const small = materializeProviderImage({ data: smallData, mimeType: "image/png" }).then(
(image) => {
completionOrder.push("small");
return image;
},
);
const images = await Promise.all([large, small]);
for (const image of images) rmSync(image.path, { force: true });
expect(completionOrder).toEqual(["small", "large"]);
});
test("publishing small distinct images stays within eight event-loop turns per image", async () => {
const count = 20;
const materializing = new AsyncLocalStorage<boolean>();
let turn = 0;
let lastActiveTurn = -1;
let activeTurns = 0;
const hook = createHook({
before() {
// A spinning immediate can tick many times while a filesystem worker is
// still running. Count only turns that advance the materializations.
if (materializing.getStore() && turn !== lastActiveTurn) {
lastActiveTurn = turn;
activeTurns++;
}
},
});
let probe = setImmediate(function tick() {
turn++;
probe = setImmediate(tick);
});
const images: string[] = [];
hook.enable();
try {
await materializing.run(true, async () => {
for (let index = 0; index < count; index++) {
const data = Buffer.from(`small attachment ${index}`).toString("base64");
const image = await materializeProviderImage({ data, mimeType: "image/png" });
images.push(image.path);
}
});
} finally {
hook.disable();
clearImmediate(probe);
for (const image of images) rmSync(image, { force: true });
}
expect(activeTurns).toBeLessThanOrEqual(8 * count);
});
test("six concurrent 8 MiB images share the main-thread CPU budget", async () => {
const inputs = Array.from({ length: 6 }, (_, index) => ({
data: Buffer.alloc(8 * 1024 * 1024, index + 1).toString("base64"),
mimeType: "image/png",
}));
const threadCpuMs = () => {
const { user, system } = process.threadCpuUsage();
return (user + system) / 1000;
};
let previous = threadCpuMs();
let longest = 0;
const probe = setInterval(() => {
const now = threadCpuMs();
longest = Math.max(longest, now - previous);
previous = now;
}, 1);
try {
const images = await Promise.all(inputs.map(materializeProviderImage));
await new Promise((resolve) => setTimeout(resolve, 5));
for (const image of images) rmSync(image.path, { force: true });
expect(longest).toBeLessThan(50);
} finally {
clearInterval(probe);
}
});
test("a busy event loop does not spend the image decode budget", async () => {
const count = 8;
let turns = 0;
let probe = setImmediate(function tick() {
turns++;
// Simulate unrelated work that exceeds a 10 ms decode slice.
const end = performance.now() + 20;
while (performance.now() < end) {
// Keep this event-loop turn busy.
}
probe = setImmediate(tick);
});
const paths: string[] = [];
try {
for (let index = 0; index < count; index++) {
const data = Buffer.from(`attachment on a busy loop ${index}`).toString("base64");
const image = await materializeProviderImage({ data, mimeType: "image/png" });
paths.push(image.path);
}
} finally {
clearImmediate(probe);
for (const image of paths) rmSync(image, { force: true });
}
expect(turns).toBeLessThanOrEqual(7 * count);
});
@@ -1,4 +1,4 @@
import { createHash } from "node:crypto";
import { createHash, randomUUID } from "node:crypto";
import * as fs from "node:fs/promises";
import { setImmediate } from "node:timers/promises";
import os from "node:os";
@@ -23,28 +23,26 @@ const PROVIDER_IMAGE_ATTACHMENT_DIR_PREFIX = `${PROVIDER_IMAGE_ATTACHMENT_DIR}-`
const PRIVATE_ATTACHMENT_DIR_MODE = 0o700;
const MATERIALIZED_IMAGE_FILE_MODE = 0o600;
let materializedImageAttachmentDir: string | null = null;
// Serialize materializations: one decoder and one file operation at a time, including
// concurrent history replay and live turns. A rejected operation must not poison the queue.
let pendingMaterialization: Promise<unknown> = Promise.resolve();
let attachmentDirectory: Promise<string> | undefined;
const pendingWrites = new Map<string, Promise<MaterializedProviderImage>>();
async function getMaterializedImageAttachmentDir(): Promise<string> {
if (materializedImageAttachmentDir) {
try {
const stats = await fs.lstat(materializedImageAttachmentDir);
if (stats.isDirectory()) {
await fs.chmod(materializedImageAttachmentDir, PRIVATE_ATTACHMENT_DIR_MODE);
return materializedImageAttachmentDir;
}
} catch {
/* Temp storage may have been removed between turns. */
}
}
materializedImageAttachmentDir = await fs.mkdtemp(
path.join(os.tmpdir(), PROVIDER_IMAGE_ATTACHMENT_DIR_PREFIX),
);
await fs.chmod(materializedImageAttachmentDir, PRIVATE_ATTACHMENT_DIR_MODE);
return materializedImageAttachmentDir;
function getMaterializedImageAttachmentDir(): Promise<string> {
attachmentDirectory ??= createAttachmentDirectory().catch((error) => {
attachmentDirectory = undefined;
throw error;
});
return attachmentDirectory;
}
async function createAttachmentDirectory(): Promise<string> {
const dir = await fs.mkdtemp(path.join(os.tmpdir(), PROVIDER_IMAGE_ATTACHMENT_DIR_PREFIX));
await fs.chmod(dir, PRIVATE_ATTACHMENT_DIR_MODE);
return dir;
}
function isMissingPath(error: unknown): boolean {
const code = (error as NodeJS.ErrnoException).code;
return code === "ENOENT" || code === "ENOTDIR";
}
function getImageExtension(mimeType: string): string {
@@ -69,18 +67,18 @@ function getImageExtension(mimeType: string): string {
// 128 MiB admits the measured 64 MiB fixture with headroom while bounding disk
// and decoding per image. This is materialization admission, not a wire schema limit.
export const MAX_PROVIDER_IMAGE_BYTES = 128 * 1024 * 1024;
const BASE64_CHUNK_CHARACTERS = 256 * 1024; // Multiple of four; decode units stay aligned.
const BASE64_CHUNK_CHARACTERS = 1024 * 1024; // Multiple of four; decode units stay aligned.
const DECODE_SLICE_MS = 10;
let decodeBudgetMs = DECODE_SLICE_MS;
let pendingDecodeYield: Promise<void> | undefined;
export function materializeProviderImage(image: {
data: string;
mimeType: string | null;
}): Promise<MaterializedProviderImage> {
const result = pendingMaterialization.then(() => materializeImage(image));
pendingMaterialization = result.catch(() => {});
return result;
async function refillDecodeBudget(): Promise<void> {
await setImmediate();
decodeBudgetMs = DECODE_SLICE_MS;
pendingDecodeYield = undefined;
}
async function materializeImage(image: {
export async function materializeProviderImage(image: {
data: string;
mimeType: string | null;
}): Promise<MaterializedProviderImage> {
@@ -103,32 +101,74 @@ async function materializeImage(image: {
}
const hash = createHash("sha256");
for await (const bytes of decodeImage(data)) hash.update(bytes);
const dir = await getMaterializedImageAttachmentDir();
const filePath = path.join(dir, `${hash.digest("hex")}.${getImageExtension(mimeType)}`);
const filename = `${hash.digest("hex")}.${getImageExtension(mimeType)}`;
const directory = getMaterializedImageAttachmentDir();
const dir = await directory;
try {
await fs.stat(filePath);
return { path: filePath };
return await materializeInDirectory(dir, filename, data);
} catch (error) {
if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
if (!isMissingPath(error)) throw error;
// Other requests may have already replaced the directory after the same deletion.
if (attachmentDirectory === directory) attachmentDirectory = undefined;
const replacement = await getMaterializedImageAttachmentDir();
return materializeInDirectory(replacement, filename, data);
}
}
const staging = await fs.mkdtemp(path.join(dir, ".pending-"));
const stagingPath = path.join(staging, "image");
function materializeInDirectory(
dir: string,
filename: string,
data: string,
): Promise<MaterializedProviderImage> {
const filePath = path.join(dir, filename);
const pending = pendingWrites.get(filePath);
if (pending) return pending;
const write = publishImage(dir, filePath, data).finally(() => {
pendingWrites.delete(filePath);
});
pendingWrites.set(filePath, write);
return write;
}
async function publishImage(
dir: string,
filePath: string,
data: string,
): Promise<MaterializedProviderImage> {
const [directory, existing] = await Promise.allSettled([fs.lstat(dir), fs.stat(filePath)]);
if (directory.status === "rejected") throw directory.reason;
const stats = directory.value;
const uid = process.platform === "win32" ? undefined : process.getuid?.();
if (
!stats.isDirectory() ||
(uid !== undefined && (stats.uid !== uid || (stats.mode & 0o077) !== 0))
) {
throw Object.assign(new Error("Private image attachment directory is unavailable"), {
code: "ENOENT",
});
}
if (existing.status === "fulfilled") return { path: filePath };
if (!isMissingPath(existing.reason)) throw existing.reason;
const stagingPath = path.join(dir, `.pending-${randomUUID()}`);
const file = await fs.open(stagingPath, "wx", MATERIALIZED_IMAGE_FILE_MODE);
try {
await fs.chmod(staging, PRIVATE_ATTACHMENT_DIR_MODE);
const file = await fs.open(stagingPath, "wx", MATERIALIZED_IMAGE_FILE_MODE);
try {
// Restore owner permissions if the umask masked them at open.
await file.chmod(MATERIALIZED_IMAGE_FILE_MODE);
// Decode again only for a new hash. This bounds retained memory to one chunk
// and performs no writes at all for repeated content, including history replay.
// Decode again only for new content, retaining one chunk at a time.
for await (const bytes of decodeImage(data)) await file.writeFile(bytes);
} finally {
await file.close();
}
await fs.rename(stagingPath, filePath);
return { path: filePath };
} finally {
await fs.rm(staging, { recursive: true, force: true });
} catch (error) {
await fs.unlink(stagingPath).catch((cleanupError) => {
if (!isMissingPath(cleanupError)) throw cleanupError;
});
throw error;
}
}
@@ -136,6 +176,13 @@ async function* decodeImage(data: string): AsyncGenerator<Buffer> {
let carry = "";
let decodedBytes = 0;
for (let offset = 0; offset < data.length; offset += BASE64_CHUNK_CHARACTERS) {
let pause = pendingDecodeYield;
while (pause) {
await pause;
pause = pendingDecodeYield;
}
// Charge synchronous work across decoders. File I/O and idle time leave the budget intact.
const startedAt = performance.now();
// Buffer.from ignores non-base64 characters. Carry incomplete quartets so
// line-wrapped payloads decode identically across chunk boundaries.
const chunk =
@@ -144,12 +191,13 @@ async function* decodeImage(data: string): AsyncGenerator<Buffer> {
const finalChunk = offset + BASE64_CHUNK_CHARACTERS >= data.length || chunk.includes("=");
const end = finalChunk ? chunk.length : chunk.length - (chunk.length % 4);
const bytes = Buffer.from(chunk.slice(0, end), "base64");
decodeBudgetMs -= performance.now() - startedAt;
if (decodeBudgetMs <= 0) pendingDecodeYield = refillDecodeBudget();
carry = chunk.slice(end);
decodedBytes += bytes.length;
if (decodedBytes > MAX_PROVIDER_IMAGE_BYTES)
throw new Error("Image attachment exceeds size limit");
yield bytes;
await setImmediate();
if (finalChunk) break;
}
}
@@ -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"];
@@ -3415,11 +3418,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(
+27 -1
View File
@@ -184,6 +184,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";
@@ -214,7 +215,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,
@@ -743,6 +747,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) => {
@@ -1166,6 +1171,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) => {
@@ -1224,6 +1231,8 @@ export async function createPaseoDaemon(
setupAutoArchiveOnMerge({
paseoHome: config.paseoHome,
paseoWorktreesBaseRoot: config.worktreesRoot,
worktreeManagers: pluginRuntime,
workspaceArchiveOperations,
daemonConfigStore,
workspaceGitService,
github,
@@ -1232,6 +1241,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,
@@ -1252,6 +1263,7 @@ export async function createPaseoDaemon(
createPaseoWorktree: async (workflowInput, workflowOptions) => {
return createRegisteredPaseoWorktree(workflowInput, {
lifecycle: pluginRuntime,
worktreeManagers: pluginRuntime,
github,
...(workflowOptions?.resolveDefaultBranch
? {
@@ -1312,6 +1324,8 @@ export async function createPaseoDaemon(
{
paseoHome: config.paseoHome,
paseoWorktreesBaseRoot: config.worktreesRoot,
worktreeManagers: pluginRuntime,
workspaceArchiveOperations,
github,
workspaceGitService,
agentManager,
@@ -1329,6 +1343,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 },
@@ -1336,6 +1351,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,
@@ -1434,6 +1453,8 @@ export async function createPaseoDaemon(
{
paseoHome: config.paseoHome,
paseoWorktreesBaseRoot: config.worktreesRoot,
worktreeManagers: pluginRuntime,
workspaceArchiveOperations,
github,
workspaceGitService,
agentManager,
@@ -1457,6 +1478,7 @@ export async function createPaseoDaemon(
stopWorkspaceSetup: (workspaceIdToStop) => workspaceSetupRuntime.stop(workspaceIdToStop),
assertWorkspaceAutomationAllowed: (guardedWorkspaceId) =>
assertWorkspaceAutomationAllowedForWorkspace(workspaceRegistry, guardedWorkspaceId),
isCheckoutUntrusted: (checkoutPath) => isCheckoutUntrusted(workspaceRegistry, checkoutPath),
sessionLogger: logger,
},
{
@@ -1583,6 +1605,9 @@ export async function createPaseoDaemon(
daemonConfigStore,
github,
workspaceGitService,
worktreeManagers: pluginRuntime,
workspaceArchiveOperations,
isCheckoutUntrusted: (checkoutPath) => isCheckoutUntrusted(workspaceRegistry, checkoutPath),
findWorkspaceIdForCwd: findWorkspaceIdForCwdExternal,
listActiveWorkspaces: listActiveWorkspacesExternal,
archiveWorkspaceRecord: (workspaceId, archivedAt) =>
@@ -1930,6 +1955,7 @@ export async function createPaseoDaemon(
pluginRuntime,
orchestrationSkills,
workspaceLabelService,
workspaceArchiveOperations,
);
pluginRuntime.bindPaseoSessionHost(wsServer);
await pluginRuntime.start();
@@ -2,6 +2,7 @@ import { mkdir, mkdtemp, rename, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { basename, dirname, join, sep } from "node:path";
import { afterEach, expect, test, vi } from "vitest";
import { createWatcherLivenessCanary } from "../watcher-liveness-canary.js";
import {
createFileObserver,
type FileChange,
@@ -167,12 +168,17 @@ test("survives atomic replacement and remains observable", async () => {
const root = await createRoot();
const target = join(root, "target.txt");
await writeFile(target, "before");
const canary = createWatcherLivenessCanary(root);
const events: FileChange[] = [];
const subscription = await subscribeToFileChanges(root, (error, batch) => {
expect(error).toBeNull();
events.push(...batch);
events.push(...canary.filterEvents(batch));
});
// macOS starts delivering native events asynchronously after subscription.
await canary.verify();
events.length = 0;
const replacement = join(root, "replacement.txt");
await writeFile(replacement, "after");
await rename(replacement, target);
@@ -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;
+30 -1
View File
@@ -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 };
}
@@ -257,6 +257,59 @@ afterEach(async () => {
});
describe("PluginRuntime", () => {
it("reports a spent create budget without blaming a manager it did not call", async () => {
const first = await createPlugin(
"first-manager",
`import { existsSync, writeFileSync } from "node:fs";
import path from "node:path";
export default function contribute(server) {
return server.registerWorktreeManager({
async create({ path: directory }, { signal }) {
writeFileSync(path.join(directory, "started"), "");
while (!existsSync(path.join(directory, "decline"))) {
signal.throwIfAborted();
await new Promise((resolve) => setTimeout(resolve, 20));
}
},
});
}`,
);
const second = await createPlugin(
"second-manager",
`export default function contribute(server) {
return server.registerWorktreeManager({
async create() { throw new Error("Second manager was called"); },
});
}`,
);
const runtime = createTestRuntime();
try {
await runtime.startPlugin("first-manager", first);
await runtime.startPlugin("second-manager", second);
// Advance the deadline clock while real subprocess IPC and timers keep running.
vi.useFakeTimers({ toFake: ["Date"] });
const creation = runtime.createWorktree({
kind: "branch-off",
repoRoot: first,
sourceCheckout: first,
branch: "topic",
slug: "topic",
path: first,
baseRef: "main",
untrusted: false,
});
const failure = creation.catch((error: unknown) => error);
await expect.poll(() => readTextIfPresent(path.join(first, "started"))).toBe("");
vi.setSystemTime(Date.now() + 120_000);
await writeFile(path.join(first, "decline"), "");
expect(await failure).toMatchObject({ message: "Worktree creation manager budget expired" });
} finally {
vi.useRealTimers();
await runtime.stopAll();
}
});
it.each([
{ specifier: "@getpaseo/plugin", moduleDirectory: "shared" },
{ specifier: "@getpaseo/plugin", moduleDirectory: "server" },
+171 -3
View File
@@ -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,109 @@ 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));
// All create callbacks share one timeout budget.
const deadline = Date.now() + WORKTREE_MANAGER_TIMEOUT_MS;
for (const loaded of plugins) {
const remainingMs = deadline - Date.now();
if (remainingMs <= 0) {
throw new Error("Worktree creation manager budget expired");
}
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 +1010,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 +1029,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 +1097,7 @@ export class PluginRuntime {
subscriptionMethods: new Set(),
subscriptions: new Map(),
hooks: [],
worktreeManager: null,
providers: [],
usageSources: [],
child: null,
@@ -1067,6 +1230,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 +1320,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 () => {
+164 -46
View File
@@ -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;
@@ -5782,11 +5823,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),
@@ -5798,6 +5842,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,
@@ -6503,9 +6549,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> {
@@ -6552,6 +6649,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 }
@@ -6582,6 +6680,8 @@ export class Session {
worktreeRoot: workspace.worktreeRoot,
isPaseoOwnedWorktree: workspace.isPaseoOwnedWorktree,
mainRepoRoot: workspace.mainRepoRoot,
worktreeManagerPluginId: workspace.worktreeManagerPluginId,
untrustedSource: workspace.untrustedSource,
}));
}
@@ -7436,24 +7536,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(
@@ -7535,34 +7640,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);
@@ -8130,6 +8242,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,
@@ -8146,6 +8260,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),
@@ -8208,7 +8324,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",
@@ -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,
@@ -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 {
+11 -3
View File
@@ -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,59 @@ test("a canceled archive with no matching agents leaves earlier closed agents ar
});
expect(restored).toEqual([]);
});
test.each(["outer", "inner"])(
"archive keeps nested workspace when %s is managed",
async (managed) => {
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,
worktreeManagerPluginId: managed === "outer" ? "manager" : null,
isPaseoOwnedWorktree: true,
mainRepoRoot: repoDir,
},
{
workspaceId: "ws-topic",
cwd: innerPath,
kind: "worktree",
worktreeRoot: innerPath,
worktreeManagerPluginId: managed === "inner" ? "manager" : null,
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({
@@ -481,7 +547,7 @@ async function maybeRemoveDirectory(
if (
!(await isDirectoryUnreferenced(
remainingActive,
backing.path,
backing,
new Set(archivedWorkspaceIds),
dependencies,
))
@@ -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 });
@@ -618,21 +688,28 @@ export async function archiveWorkspaceContents(
return archivedAgents;
}
// True when, after archiving
// the in-scope records, no active workspace still points at targetDir. Derived
// from records each call — no stored counter.
// Active workspaces on the same checkout keep it alive. A manager can place
// a checkout anywhere, so also protect nested workspaces when either checkout
// is manager-owned.
async function isDirectoryUnreferenced(
activeWorkspaces: ActiveWorkspaceRef[],
targetDir: string,
targetDirectory: BackingDirectory,
archivedWorkspaceIds: ReadonlySet<string>,
dependencies: Pick<ArchiveDependencies, "paseoHome" | "paseoWorktreesBaseRoot">,
): Promise<boolean> {
const target = resolve(targetDir);
const target = targetDirectory.path;
const matchesTarget = createRealpathAwarePathMatcher(target);
for (const workspace of activeWorkspaces) {
if (archivedWorkspaceIds.has(workspace.workspaceId)) continue;
const backingDirectory = await resolveWorkspaceBackingDirectory(workspace, dependencies);
if (matchesTarget(backingDirectory.path)) return false;
if (
(targetDirectory.worktreeManagerPluginId || backingDirectory.worktreeManagerPluginId) &&
(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.
+73 -1
View File
@@ -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 };
+21 -1
View File
@@ -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);
});
+11 -11
View File
@@ -47,24 +47,24 @@ 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`,
);
throw new Error(`The returned path is relative: ${candidate}. Use an absolute path.`);
}
const normalized = await normalizeCandidatePath(candidate);
const normalizedRepoPath = await normalizeAbsolute(repoPath);
if (normalized === parse(normalized).root) {
throw new Error("Worktree hook returned the filesystem root, which is not allowed");
throw new Error("The filesystem root cannot be a worktree destination");
}
if (normalized === (await normalizeAbsolute(homedir()))) {
throw new Error("Worktree hook returned the user's home directory, which is not allowed");
throw new Error("The user's home directory cannot be a worktree destination");
}
if (normalized === normalizedRepoPath) {
throw new Error("Worktree hook returned the repository root itself, which is not allowed");
throw new Error("The repository root cannot be a worktree destination");
}
if (
[normalized, resolve(candidate)].some((path) =>
@@ -73,15 +73,15 @@ export async function validateWorktreePath(options: {
.some((part) => (process.platform === "win32" ? part.toLowerCase() : part) === ".git"),
)
) {
throw new Error(`Worktree hook returned a path inside a .git directory: ${normalized}`);
throw new Error(`The returned path is inside a .git directory: ${normalized}`);
}
const relativeToCandidate = getRelativePathInsideRoot(normalized, normalizedRepoPath);
if (relativeToCandidate !== null && relativeToCandidate !== "") {
throw new Error(`Worktree hook returned an ancestor of the repository: ${normalized}`);
throw new Error(`The returned path is 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.`,
`The returned path already exists: ${normalized}. Paseo creates the returned path.`,
);
}
return normalized;
File diff suppressed because it is too large Load Diff
@@ -28,17 +28,28 @@ index 73466dd..8440ac9 100644
auto textSize = textLayoutManager_
diff --git a/node_modules/@mattermost/react-native-paste-input/android/src/main/java/com/mattermost/pasteinputtext/PasteInputEditText.kt b/node_modules/@mattermost/react-native-paste-input/android/src/main/java/com/mattermost/pasteinputtext/PasteInputEditText.kt
index 9e429b8..1d10014 100644
index 1794b53..eca5e57 100644
--- a/node_modules/@mattermost/react-native-paste-input/android/src/main/java/com/mattermost/pasteinputtext/PasteInputEditText.kt
+++ b/node_modules/@mattermost/react-native-paste-input/android/src/main/java/com/mattermost/pasteinputtext/PasteInputEditText.kt
@@ -36,2 +36,2 @@ class PasteInputEditText(context: ThemedReactContext) : ReactEditText(context) {
@@ -33,8 +33,8 @@ class PasteInputEditText(context: ThemedReactContext) : ReactEditText(context) {
return mOnPasteListener
}
- override fun onCreateInputConnection(outAttrs: EditorInfo): InputConnection {
- val ic = super.onCreateInputConnection(outAttrs)
+ override fun onCreateInputConnection(outAttrs: EditorInfo): InputConnection? {
+ val ic = super.onCreateInputConnection(outAttrs) ?: return null
@@ -58 +58 @@ class PasteInputEditText(context: ThemedReactContext) : ReactEditText(context) {
EditorInfoCompat.setContentMimeTypes(outAttrs, arrayOf("*/*"))
@@ -55,6 +55,6 @@ class PasteInputEditText(context: ThemedReactContext) : ReactEditText(context) {
true
}
- return InputConnectionCompat.createWrapper(ic!!, outAttrs, callback)
+ return InputConnectionCompat.createWrapper(ic, outAttrs, callback)
}
}
diff --git a/node_modules/@mattermost/react-native-paste-input/lib/commonjs/PasteInput.js b/node_modules/@mattermost/react-native-paste-input/lib/commonjs/PasteInput.js
index 51b9dfa..501badf 100644
--- a/node_modules/@mattermost/react-native-paste-input/lib/commonjs/PasteInput.js
@@ -108,10 +119,18 @@ index 51b9dfa..501badf 100644
// For Android, PasteTextInput already handles everything internally
// Just need to adapt the onPaste callback format
diff --git a/node_modules/@mattermost/react-native-paste-input/lib/commonjs/PasteTextInput.js b/node_modules/@mattermost/react-native-paste-input/lib/commonjs/PasteTextInput.js
index 5119e65..287216a 100644
index 5119e65..77c3aea 100644
--- a/node_modules/@mattermost/react-native-paste-input/lib/commonjs/PasteTextInput.js
+++ b/node_modules/@mattermost/react-native-paste-input/lib/commonjs/PasteTextInput.js
@@ -52,6 +52,7 @@ function InternalTextInput(props) {
@@ -16,7 +16,6 @@ var _nullthrows = _interopRequireDefault(require("nullthrows"));
var _jsxRuntime = require("react/jsx-runtime");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-const emptyFunctionThatReturnsTrue = () => true;
function useMergeRefs(...refs) {
return React.useCallback(current => {
for (const ref of refs) {
@@ -52,6 +51,7 @@ function InternalTextInput(props) {
end: propsSelection.end ?? propsSelection.start
}, [propsSelection]);
const [mostRecentEventCount, setMostRecentEventCount] = React.useState(0);
@@ -119,7 +138,7 @@ index 5119e65..287216a 100644
const [lastNativeText, setLastNativeText] = React.useState(props.value);
const [lastNativeSelectionState, setLastNativeSelection] = React.useState({
selection: {
@@ -103,7 +104,12 @@ function InternalTextInput(props) {
@@ -103,7 +103,12 @@ function InternalTextInput(props) {
Object.assign(instance, {
clear() {
if (inputRef.current != null) {
@@ -133,7 +152,7 @@ index 5119e65..287216a 100644
}
},
isFocused() {
@@ -114,12 +120,12 @@ function InternalTextInput(props) {
@@ -114,12 +119,12 @@ function InternalTextInput(props) {
},
setSelection(start, end) {
if (inputRef.current != null) {
@@ -148,7 +167,7 @@ index 5119e65..287216a 100644
const ref = useMergeRefs(setLocalRef, props.forwardedRef);
const _onChange = event => {
const currentText = event.nativeEvent.text;
@@ -128,6 +134,7 @@ function InternalTextInput(props) {
@@ -128,6 +133,7 @@ function InternalTextInput(props) {
if (inputRef.current == null) {
return;
}
@@ -156,6 +175,14 @@ index 5119e65..287216a 100644
setLastNativeText(currentText);
setMostRecentEventCount(event.nativeEvent.eventCount);
};
@@ -294,7 +300,6 @@ function InternalTextInput(props) {
onPaste: _onPaste,
onScroll: _onScroll,
onSelectionChange: _onSelectionChange,
- onSelectionChangeShouldSetResponder: emptyFunctionThatReturnsTrue,
placeholder: placeholder,
style: _style,
text: text,
diff --git a/node_modules/@mattermost/react-native-paste-input/lib/module/PasteInput.js b/node_modules/@mattermost/react-native-paste-input/lib/module/PasteInput.js
index 75fe015..1d3cd64 100644
--- a/node_modules/@mattermost/react-native-paste-input/lib/module/PasteInput.js
@@ -225,10 +252,18 @@ index 75fe015..1d3cd64 100644
// For Android, PasteTextInput already handles everything internally
// Just need to adapt the onPaste callback format
diff --git a/node_modules/@mattermost/react-native-paste-input/lib/module/PasteTextInput.js b/node_modules/@mattermost/react-native-paste-input/lib/module/PasteTextInput.js
index 39bd607..f2b1d2f 100644
index 39bd607..832dcc2 100644
--- a/node_modules/@mattermost/react-native-paste-input/lib/module/PasteTextInput.js
+++ b/node_modules/@mattermost/react-native-paste-input/lib/module/PasteTextInput.js
@@ -46,6 +46,7 @@ function InternalTextInput(props) {
@@ -10,7 +10,6 @@ import usePressability from 'react-native/Libraries/Pressability/usePressability
import flattenStyle from 'react-native/Libraries/StyleSheet/flattenStyle';
import nullthrows from 'nullthrows';
import { jsx as _jsx } from "react/jsx-runtime";
-const emptyFunctionThatReturnsTrue = () => true;
function useMergeRefs(...refs) {
return React.useCallback(current => {
for (const ref of refs) {
@@ -46,6 +45,7 @@ function InternalTextInput(props) {
end: propsSelection.end ?? propsSelection.start
}, [propsSelection]);
const [mostRecentEventCount, setMostRecentEventCount] = React.useState(0);
@@ -236,7 +271,7 @@ index 39bd607..f2b1d2f 100644
const [lastNativeText, setLastNativeText] = React.useState(props.value);
const [lastNativeSelectionState, setLastNativeSelection] = React.useState({
selection: {
@@ -97,7 +98,12 @@ function InternalTextInput(props) {
@@ -97,7 +97,12 @@ function InternalTextInput(props) {
Object.assign(instance, {
clear() {
if (inputRef.current != null) {
@@ -250,7 +285,7 @@ index 39bd607..f2b1d2f 100644
}
},
isFocused() {
@@ -108,12 +114,12 @@ function InternalTextInput(props) {
@@ -108,12 +113,12 @@ function InternalTextInput(props) {
},
setSelection(start, end) {
if (inputRef.current != null) {
@@ -265,7 +300,7 @@ index 39bd607..f2b1d2f 100644
const ref = useMergeRefs(setLocalRef, props.forwardedRef);
const _onChange = event => {
const currentText = event.nativeEvent.text;
@@ -122,6 +128,7 @@ function InternalTextInput(props) {
@@ -122,6 +127,7 @@ function InternalTextInput(props) {
if (inputRef.current == null) {
return;
}
@@ -273,6 +308,14 @@ index 39bd607..f2b1d2f 100644
setLastNativeText(currentText);
setMostRecentEventCount(event.nativeEvent.eventCount);
};
@@ -288,7 +294,6 @@ function InternalTextInput(props) {
onPaste: _onPaste,
onScroll: _onScroll,
onSelectionChange: _onSelectionChange,
- onSelectionChangeShouldSetResponder: emptyFunctionThatReturnsTrue,
placeholder: placeholder,
style: _style,
text: text,
diff --git a/node_modules/@mattermost/react-native-paste-input/src/PasteInput.tsx b/node_modules/@mattermost/react-native-paste-input/src/PasteInput.tsx
index 12befab..0d23ca5 100644
--- a/node_modules/@mattermost/react-native-paste-input/src/PasteInput.tsx
@@ -342,10 +385,19 @@ index 12befab..0d23ca5 100644
// For Android, PasteTextInput already handles everything internally
// Just need to adapt the onPaste callback format
diff --git a/node_modules/@mattermost/react-native-paste-input/src/PasteTextInput.tsx b/node_modules/@mattermost/react-native-paste-input/src/PasteTextInput.tsx
index dcc4a2b..1156458 100644
index dcc4a2b..7d10e11 100644
--- a/node_modules/@mattermost/react-native-paste-input/src/PasteTextInput.tsx
+++ b/node_modules/@mattermost/react-native-paste-input/src/PasteTextInput.tsx
@@ -84,6 +84,7 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
@@ -27,8 +27,6 @@ import usePressability from 'react-native/Libraries/Pressability/usePressability
import flattenStyle from 'react-native/Libraries/StyleSheet/flattenStyle';
import nullthrows from 'nullthrows';
-const emptyFunctionThatReturnsTrue = () => true;
-
function useMergeRefs<Instance>(
...refs: ReadonlyArray<React.ForwardedRef<Instance> | null | undefined>
): (arg0: Instance | null) => void {
@@ -84,6 +82,7 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
const [mostRecentEventCount, setMostRecentEventCount] =
React.useState<number>(0);
@@ -353,7 +405,7 @@ index dcc4a2b..1156458 100644
const [lastNativeText, setLastNativeText] = React.useState<
string | undefined
>(props.value);
@@ -181,13 +182,24 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
@@ -181,13 +180,24 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
if (inputRef.current != null) {
Commands.setTextAndSelection(
inputRef.current,
@@ -379,7 +431,7 @@ index dcc4a2b..1156458 100644
isFocused(): boolean {
return (
TextInputState.currentlyFocusedInput() ===
@@ -203,7 +215,7 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
@@ -203,7 +213,7 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
if (inputRef.current != null) {
Commands.setTextAndSelection(
inputRef.current,
@@ -388,7 +440,7 @@ index dcc4a2b..1156458 100644
null,
start,
end
@@ -213,7 +225,7 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
@@ -213,7 +223,7 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
});
}
},
@@ -397,7 +449,7 @@ index dcc4a2b..1156458 100644
);
const ref = useMergeRefs<PasteTextInputInstance>(
@@ -232,6 +244,7 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
@@ -232,6 +242,7 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
return;
}
@@ -405,3 +457,11 @@ index dcc4a2b..1156458 100644
setLastNativeText(currentText);
setMostRecentEventCount(event.nativeEvent.eventCount);
};
@@ -445,7 +456,6 @@ function InternalTextInput(props: PasteInputProps): React.ReactNode {
onPaste={_onPaste}
onScroll={_onScroll}
onSelectionChange={_onSelectionChange}
- onSelectionChangeShouldSetResponder={emptyFunctionThatReturnsTrue}
placeholder={placeholder}
style={_style}
text={text}
+223
View File
@@ -0,0 +1,223 @@
diff --git a/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-dev.js b/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-dev.js
index daab0e3..d3a629c 100644
--- a/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-dev.js
+++ b/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-dev.js
@@ -16214,12 +16214,21 @@ __DEV__ &&
else if (
"topTouchEnd" === topLevelType ||
"topTouchCancel" === topLevelType
- )
- if (
- (nativeEvent.changedTouches.forEach(recordTouchEnd),
- (touchHistory.numberActiveTouches = nativeEvent.touches.length),
- 1 === touchHistory.numberActiveTouches)
- ) {
+ ) {
+ nativeEvent.changedTouches.forEach(recordTouchEnd);
+ touchHistory.numberActiveTouches = nativeEvent.touches.length;
+ if (0 === touchHistory.numberActiveTouches) {
+ for (
+ topLevelType = 0;
+ topLevelType < touchBank.length;
+ topLevelType++
+ )
+ if (
+ ((nativeEvent = touchBank[topLevelType]),
+ null != nativeEvent && nativeEvent.touchActive)
+ )
+ nativeEvent.touchActive = !1;
+ } else if (1 === touchHistory.numberActiveTouches) {
for (
topLevelType = 0;
topLevelType < touchBank.length;
@@ -16236,6 +16245,7 @@ __DEV__ &&
(null != topLevelType && topLevelType.touchActive) ||
console.error("Cannot find single active touch.");
}
+ }
},
touchHistory: touchHistory
},
@@ -16314,12 +16324,18 @@ __DEV__ &&
nativeEvent,
nativeEventTarget
) {
- if (isStartish(topLevelType)) trackedTouchCount += 1;
+ if (isStartish(topLevelType))
+ trackedTouchCount =
+ nativeEvent && Array.isArray(nativeEvent.touches)
+ ? nativeEvent.touches.length
+ : trackedTouchCount + 1;
else if (
"topTouchEnd" === topLevelType ||
"topTouchCancel" === topLevelType
)
- if (0 <= trackedTouchCount) --trackedTouchCount;
+ if (nativeEvent && Array.isArray(nativeEvent.touches))
+ trackedTouchCount = nativeEvent.touches.length;
+ else if (0 <= trackedTouchCount) --trackedTouchCount;
else
return (
console.warn(
diff --git a/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-prod.js b/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-prod.js
index 2625bf6..3d85e32 100644
--- a/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-prod.js
+++ b/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-prod.js
@@ -546,12 +546,21 @@ var instrumentationCallback,
else if (
"topTouchEnd" === topLevelType ||
"topTouchCancel" === topLevelType
- )
- if (
- (nativeEvent.changedTouches.forEach(recordTouchEnd),
- (touchHistory.numberActiveTouches = nativeEvent.touches.length),
- 1 === touchHistory.numberActiveTouches)
- )
+ ) {
+ nativeEvent.changedTouches.forEach(recordTouchEnd);
+ touchHistory.numberActiveTouches = nativeEvent.touches.length;
+ if (0 === touchHistory.numberActiveTouches) {
+ for (
+ topLevelType = 0;
+ topLevelType < touchBank.length;
+ topLevelType++
+ )
+ if (
+ ((nativeEvent = touchBank[topLevelType]),
+ null != nativeEvent && nativeEvent.touchActive)
+ )
+ nativeEvent.touchActive = !1;
+ } else if (1 === touchHistory.numberActiveTouches)
for (
topLevelType = 0;
topLevelType < touchBank.length;
@@ -564,6 +573,7 @@ var instrumentationCallback,
touchHistory.indexOfSingleActiveTouch = topLevelType;
break;
}
+ }
},
touchHistory: touchHistory
};
@@ -745,12 +755,18 @@ var ResponderEventPlugin = {
nativeEvent,
nativeEventTarget
) {
- if (isStartish(topLevelType)) trackedTouchCount += 1;
+ if (isStartish(topLevelType))
+ trackedTouchCount =
+ nativeEvent && Array.isArray(nativeEvent.touches)
+ ? nativeEvent.touches.length
+ : trackedTouchCount + 1;
else if (
"topTouchEnd" === topLevelType ||
"topTouchCancel" === topLevelType
)
- if (0 <= trackedTouchCount) --trackedTouchCount;
+ if (nativeEvent && Array.isArray(nativeEvent.touches))
+ trackedTouchCount = nativeEvent.touches.length;
+ else if (0 <= trackedTouchCount) --trackedTouchCount;
else return null;
ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
if (
diff --git a/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-profiling.js b/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-profiling.js
index 544c754..4d5ec08 100644
--- a/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-profiling.js
+++ b/node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-profiling.js
@@ -611,12 +611,21 @@ var instrumentationCallback,
else if (
"topTouchEnd" === topLevelType ||
"topTouchCancel" === topLevelType
- )
- if (
- (nativeEvent.changedTouches.forEach(recordTouchEnd),
- (touchHistory.numberActiveTouches = nativeEvent.touches.length),
- 1 === touchHistory.numberActiveTouches)
- )
+ ) {
+ nativeEvent.changedTouches.forEach(recordTouchEnd);
+ touchHistory.numberActiveTouches = nativeEvent.touches.length;
+ if (0 === touchHistory.numberActiveTouches) {
+ for (
+ topLevelType = 0;
+ topLevelType < touchBank.length;
+ topLevelType++
+ )
+ if (
+ ((nativeEvent = touchBank[topLevelType]),
+ null != nativeEvent && nativeEvent.touchActive)
+ )
+ nativeEvent.touchActive = !1;
+ } else if (1 === touchHistory.numberActiveTouches)
for (
topLevelType = 0;
topLevelType < touchBank.length;
@@ -629,6 +638,7 @@ var instrumentationCallback,
touchHistory.indexOfSingleActiveTouch = topLevelType;
break;
}
+ }
},
touchHistory: touchHistory
};
@@ -810,12 +820,18 @@ var ResponderEventPlugin = {
nativeEvent,
nativeEventTarget
) {
- if (isStartish(topLevelType)) trackedTouchCount += 1;
+ if (isStartish(topLevelType))
+ trackedTouchCount =
+ nativeEvent && Array.isArray(nativeEvent.touches)
+ ? nativeEvent.touches.length
+ : trackedTouchCount + 1;
else if (
"topTouchEnd" === topLevelType ||
"topTouchCancel" === topLevelType
)
- if (0 <= trackedTouchCount) --trackedTouchCount;
+ if (nativeEvent && Array.isArray(nativeEvent.touches))
+ trackedTouchCount = nativeEvent.touches.length;
+ else if (0 <= trackedTouchCount) --trackedTouchCount;
else return null;
ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
if (
diff --git a/node_modules/react-native/src/private/renderer/events/ReactNativeResponder.js b/node_modules/react-native/src/private/renderer/events/ReactNativeResponder.js
index da29336..7167a2f 100644
--- a/node_modules/react-native/src/private/renderer/events/ReactNativeResponder.js
+++ b/node_modules/react-native/src/private/renderer/events/ReactNativeResponder.js
@@ -560,9 +560,13 @@ export function processResponderEvent(
): void {
// Track touch count
if (isStartish(topLevelType)) {
- trackedTouchCount += 1;
+ trackedTouchCount = Array.isArray(nativeEvent.touches)
+ ? nativeEvent.touches.length
+ : trackedTouchCount + 1;
} else if (isEndish(topLevelType)) {
- if (trackedTouchCount >= 0) {
+ if (Array.isArray(nativeEvent.touches)) {
+ trackedTouchCount = nativeEvent.touches.length;
+ } else if (trackedTouchCount >= 0) {
trackedTouchCount -= 1;
} else {
if (__DEV__) {
diff --git a/node_modules/react-native/src/private/renderer/events/ResponderTouchHistoryStore.js b/node_modules/react-native/src/private/renderer/events/ResponderTouchHistoryStore.js
index c0b4d12..b4aab95 100644
--- a/node_modules/react-native/src/private/renderer/events/ResponderTouchHistoryStore.js
+++ b/node_modules/react-native/src/private/renderer/events/ResponderTouchHistoryStore.js
@@ -234,7 +234,14 @@ const ResponderTouchHistoryStore = {
} else if (isEndish(topLevelType)) {
nativeEvent.changedTouches.forEach(recordTouchEnd);
touchHistory.numberActiveTouches = nativeEvent.touches.length;
- if (touchHistory.numberActiveTouches === 1) {
+ if (touchHistory.numberActiveTouches === 0) {
+ for (let i = 0; i < touchBank.length; i++) {
+ const touchTrackToCheck = touchBank[i];
+ if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {
+ touchTrackToCheck.touchActive = false;
+ }
+ }
+ } else if (touchHistory.numberActiveTouches === 1) {
for (let i = 0; i < touchBank.length; i++) {
const touchTrackToCheck = touchBank[i];
if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {
@@ -350,18 +350,10 @@ index b849f78..24c06f3 100644
factory: RendererFactory,
) {
diff --git a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/renderer/ListRenderer.kt b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/renderer/ListRenderer.kt
index 2bac5b1..021debd 100644
index 2bac5b1..ff2d2c2 100644
--- a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/renderer/ListRenderer.kt
+++ b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/renderer/ListRenderer.kt
@@ -6,6 +6,7 @@ import com.swmansion.enriched.markdown.spans.ListItemSpacingSpan
import com.swmansion.enriched.markdown.spans.MarginBottomSpan
import com.swmansion.enriched.markdown.styles.ListStyle
import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_LINE_HEIGHT_PRIORITY
import com.swmansion.enriched.markdown.utils.text.span.applyLineHeightSkippingImages
import com.swmansion.enriched.markdown.utils.text.span.applyMarginTop
@@ -16,7 +17,7 @@ class ListRenderer(
@@ -16,7 +16,7 @@ class ListRenderer(
override fun render(
node: MarkdownASTNode,
builder: SpannableStringBuilder,
@@ -370,23 +362,6 @@ index 2bac5b1..021debd 100644
onLinkLongPress: ((String) -> Unit)?,
factory: RendererFactory,
) {
@@ -68,7 +69,15 @@ class ListRenderer(
// TODO: LineHeightSpan may also clip superscript/subscript glyphs that extend
// outside the normal line bounds. A similar "skip" strategy as for images may
// be needed here once super/subscript usage in practice is better understood.
- applyLineHeightSkippingImages(builder, start, builder.length, style.lineHeight)
+ // Priority flag so the list-wide line height iterates before inner block spacer
+ // spans (blockquote padding/margin, heading margin) instead of inflating them.
+ applyLineHeightSkippingImages(
+ builder,
+ start,
+ builder.length,
+ style.lineHeight,
+ SPAN_FLAGS_LINE_HEIGHT_PRIORITY,
+ )
// Item spacing and external bottom margin are only handled by the root-level list
if (depth == 0) {
diff --git a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/renderer/NodeRenderer.kt b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/renderer/NodeRenderer.kt
index 354b31a..77b1e14 100644
--- a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/renderer/NodeRenderer.kt
@@ -3031,18 +3006,10 @@ index 0000000..11911c8
+ }
+}
diff --git a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/MeasurementStore.kt b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/MeasurementStore.kt
index f4840e4..6b7e61f 100644
index f4840e4..e36b444 100644
--- a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/MeasurementStore.kt
+++ b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/MeasurementStore.kt
@@ -45,6 +45,7 @@ import com.swmansion.enriched.markdown.utils.common.parseLinkPillContent
import com.swmansion.enriched.markdown.utils.common.parseLinkRecognition
import com.swmansion.enriched.markdown.utils.text.extensions.replaceMathSpansWithPlaceholders
import com.swmansion.enriched.markdown.utils.text.span.prepareWidthAwareSpans
+import com.swmansion.enriched.markdown.utils.text.view.wrapForInsertionOrderedLayout
import java.util.concurrent.ConcurrentHashMap
import kotlin.math.ceil
@@ -66,9 +67,11 @@ object MeasurementStore {
@@ -66,9 +66,11 @@ object MeasurementStore {
val spannable: CharSequence?,
val paintParams: PaintParams,
val markdownHash: Int,
@@ -3054,7 +3021,7 @@ index f4840e4..6b7e61f 100644
// Store font scaling settings per view ID
private data class FontScalingSettings(
@@ -133,7 +136,10 @@ object MeasurementStore {
@@ -133,7 +135,10 @@ object MeasurementStore {
YogaMeasureOutput.getHeight(newSize) + PixelUtil.toDIPFromPixel(trailingMarginBottomPx),
)
}
@@ -3066,7 +3033,7 @@ index f4840e4..6b7e61f 100644
return oldSize != newSize
}
@@ -144,7 +150,7 @@ object MeasurementStore {
@@ -144,7 +149,7 @@ object MeasurementStore {
}
fun invalidate(id: Int) {
@@ -3075,7 +3042,7 @@ index f4840e4..6b7e61f 100644
}
// Content-box width (px) the measure pass last wrapped at; the display view insets to match (#805).
@@ -212,7 +218,7 @@ object MeasurementStore {
@@ -212,7 +217,7 @@ object MeasurementStore {
val previous = fontScalingSettings[viewId]
fontScalingSettings[viewId] = FontScalingSettings(allowFontScaling, maxFontSizeMultiplier)
if (previous != null && (previous.allowFontScaling != allowFontScaling || previous.maxFontSizeMultiplier != maxFontSizeMultiplier)) {
@@ -3084,7 +3051,7 @@ index f4840e4..6b7e61f 100644
}
}
@@ -285,7 +291,43 @@ object MeasurementStore {
@@ -285,7 +290,43 @@ object MeasurementStore {
val fontScale = checkAndUpdateFontScale(context, allowFontScaling, maxFontSizeMultiplier)
@@ -3129,7 +3096,7 @@ index f4840e4..6b7e61f 100644
if (splitTableSegments) {
return measureAndCacheSplit(context, id, width, props, allowFontScaling, fontScale, maxFontSizeMultiplier)
}
@@ -295,7 +337,7 @@ object MeasurementStore {
@@ -295,7 +336,7 @@ object MeasurementStore {
val currentHash = computePropsHash(props, allowFontScaling, fontScale, maxFontSizeMultiplier)
@@ -3138,7 +3105,7 @@ index f4840e4..6b7e61f 100644
return measureAndCache(context, safeId, width, props, allowFontScaling, fontScale, maxFontSizeMultiplier)
}
@@ -332,8 +374,11 @@ object MeasurementStore {
@@ -332,8 +373,11 @@ object MeasurementStore {
val imageRequestHeaders = parseImageRequestHeaders(props.getArrayOrNull("imageRequestHeaders"))
val linkPillContent = parseLinkPillContent(props.getArrayOrNull("linkPillContent"))
var result = markdown.hashCode()
@@ -3152,7 +3119,7 @@ index f4840e4..6b7e61f 100644
result = 31 * result + parseLinkRecognition(props.getMapOrNull("linkRecognition")).hashCode()
result = 31 * result + fontScale.toBits()
result = 31 * result + allowFontScaling.hashCode()
@@ -356,6 +401,7 @@ object MeasurementStore {
@@ -356,6 +400,7 @@ object MeasurementStore {
if (lastKnownFontScale != 1.0f) {
lastKnownFontScale = 1.0f
data.clear()
@@ -3160,7 +3127,7 @@ index f4840e4..6b7e61f 100644
}
return 1.0f
}
@@ -368,6 +414,7 @@ object MeasurementStore {
@@ -368,6 +413,7 @@ object MeasurementStore {
if (currentFontScale != lastKnownFontScale) {
lastKnownFontScale = currentFontScale
data.clear()
@@ -3168,52 +3135,6 @@ index f4840e4..6b7e61f 100644
}
return currentFontScale
}
@@ -635,7 +682,7 @@ object MeasurementStore {
}
}
- private fun createStaticLayout(
+ internal fun createStaticLayout(
text: CharSequence,
fontSize: Float,
widthPx: Int,
@@ -643,8 +690,9 @@ object MeasurementStore {
): StaticLayout {
measurePaint.textSize = fontSize
prepareWidthAwareSpans(text, widthPx)
+ val measuredText = wrapForInsertionOrderedLayout(text)
return StaticLayout.Builder
- .obtain(text, 0, text.length, measurePaint, widthPx)
+ .obtain(measuredText, 0, measuredText.length, measurePaint, widthPx)
.setIncludePad(false)
.setLineSpacing(0f, 1f)
.apply {
@@ -730,10 +778,11 @@ object MeasurementStore {
val content = text ?: ""
val safeWidth = ceil(maxWidth).toInt().coerceAtLeast(1)
prepareWidthAwareSpans(content, safeWidth)
+ val measuredText = wrapForInsertionOrderedLayout(content)
val builder =
StaticLayout.Builder
- .obtain(content, 0, content.length, paint, safeWidth)
+ .obtain(measuredText, 0, measuredText.length, paint, safeWidth)
.setIncludePad(false)
.setLineSpacing(0f, 1f)
@@ -836,10 +885,11 @@ object MeasurementStore {
val content = text ?: ""
val widthPx = ceil(maxWidth).toInt().coerceAtLeast(1)
prepareWidthAwareSpans(content, widthPx)
+ val measuredText = wrapForInsertionOrderedLayout(content)
val layout =
StaticLayout.Builder
- .obtain(content, 0, content.length, paint, widthPx)
+ .obtain(measuredText, 0, measuredText.length, paint, widthPx)
.setIncludePad(false)
.setLineSpacing(0f, 1f)
.apply {
diff --git a/node_modules/react-native-enriched-markdown/android/src/test/java/com/swmansion/enriched/markdown/MeasurementSizeCacheTest.kt b/node_modules/react-native-enriched-markdown/android/src/test/java/com/swmansion/enriched/markdown/MeasurementSizeCacheTest.kt
new file mode 100644
index 0000000..b3394c4
@@ -4075,290 +3996,3 @@ diff --git a/node_modules/react-native-enriched-markdown/lib/module/web/utils.js
+}
//# sourceMappingURL=utils.js.map
\ No newline at end of file
diff --git a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/text/view/TextViewSetup.kt b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/text/view/TextViewSetup.kt
index 4b2ad01..8742c0c 100644
--- a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/text/view/TextViewSetup.kt
+++ b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/utils/text/view/TextViewSetup.kt
@@ -11,6 +11,9 @@ import androidx.appcompat.widget.AppCompatTextView
import androidx.core.view.ViewCompat
import com.swmansion.enriched.markdown.accessibility.AccessibleMarkdownTextView
+internal fun wrapForInsertionOrderedLayout(source: CharSequence): CharSequence =
+ if (source is SpannableStringBuilder) InsertionOrderedSpannable(source) else source
+
/**
* Adopts the renderer's buffer instead of copying it: the default factory's copy is
* quadratic in span count. Safe because each segment's buffer is owned by one view.
diff --git a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/segments/SegmentHeightMeasurer.kt b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/segments/SegmentHeightMeasurer.kt
index 162ebfb..6e40bd8 100644
--- a/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/segments/SegmentHeightMeasurer.kt
+++ b/node_modules/react-native-enriched-markdown/android/src/main/java/com/swmansion/enriched/markdown/segments/SegmentHeightMeasurer.kt
@@ -9,6 +9,7 @@ import android.text.TextPaint
import com.swmansion.enriched.markdown.styles.StyleConfig
import com.swmansion.enriched.markdown.utils.text.extensions.replaceMathSpansWithPlaceholders
import com.swmansion.enriched.markdown.utils.text.span.prepareWidthAwareSpans
+import com.swmansion.enriched.markdown.utils.text.view.wrapForInsertionOrderedLayout
import kotlin.math.ceil
/**
@@ -105,8 +106,9 @@ object SegmentHeightMeasurer {
textSize = fontSizePx
}
prepareWidthAwareSpans(text, widthPx)
+ val measuredText = wrapForInsertionOrderedLayout(text)
return StaticLayout.Builder
- .obtain(text, 0, text.length, paint, widthPx)
+ .obtain(measuredText, 0, measuredText.length, paint, widthPx)
.setIncludePad(false)
.setLineSpacing(0f, 1f)
.apply {
diff --git a/b/node_modules/react-native-enriched-markdown/android/src/test/java/com/swmansion/enriched/markdown/ListBlockquoteMeasurementTest.kt b/node_modules/react-native-enriched-markdown/android/src/test/java/com/swmansion/enriched/markdown/ListBlockquoteMeasurementTest.kt
new file mode 100644
index 0000000..6115a30
--- /dev/null
+++ b/node_modules/react-native-enriched-markdown/android/src/test/java/com/swmansion/enriched/markdown/ListBlockquoteMeasurementTest.kt
@@ -0,0 +1,244 @@
+package com.swmansion.enriched.markdown
+
+import android.graphics.Paint
+import android.text.Layout
+import android.text.SpannableStringBuilder
+import android.text.style.LineHeightSpan as AndroidLineHeightSpan
+import android.util.TypedValue
+import android.view.View.MeasureSpec
+import com.facebook.react.bridge.JavaOnlyArray
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.uimanager.DisplayMetricsHolder
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode
+import com.swmansion.enriched.markdown.parser.MarkdownASTNode.NodeType
+import com.swmansion.enriched.markdown.renderer.Renderer
+import com.swmansion.enriched.markdown.segments.SegmentHeightMeasurer
+import com.swmansion.enriched.markdown.spans.LineHeightSpan
+import com.swmansion.enriched.markdown.styles.StyleConfig
+import com.swmansion.enriched.markdown.utils.text.span.SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
+
+@RunWith(RobolectricTestRunner::class)
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
+@Config(manifest = Config.NONE, sdk = [34])
+class ListBlockquoteMeasurementTest {
+ private fun styleConfig(): StyleConfig {
+ val context = RuntimeEnvironment.getApplication()
+ DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(context)
+ val base =
+ JavaOnlyMap.of(
+ "fontFamily", "",
+ "fontWeight", "normal",
+ "fontStyle", "normal",
+ "fontSize", 16.0,
+ "lineHeight", 22.0,
+ "color", -16777216.0,
+ "backgroundColor", 0.0,
+ "borderColor", 0.0,
+ "borderWidth", 3.0,
+ "borderRadius", 0.0,
+ "padding", 12.0,
+ "gapWidth", 8.0,
+ "marginTop", 0.0,
+ "marginBottom", 12.0,
+ "marginLeft", 20.0,
+ "itemSpacing", 4.0,
+ "bulletColor", -16777216.0,
+ "bulletSize", 6.0,
+ "markerMinWidth", 0.0,
+ "markerColor", -16777216.0,
+ "markerFontWeight", "normal",
+ "textAlign", "left",
+ "underline", false,
+ "checkedColor", 0.0,
+ "checkmarkColor", 0.0,
+ "checkedTextColor", 0.0,
+ "checkboxSize", 18.0,
+ "checkboxBorderRadius", 2.0,
+ "checkedStrikethrough", false,
+ "particles", JavaOnlyMap.of("density", 1.0, "speed", 1.0),
+ "solid", JavaOnlyMap.of("borderRadius", 0.0),
+ "fontScale", 0.7,
+ "baselineOffsetScale", 0.3,
+ )
+ val styles = JavaOnlyMap()
+ listOf(
+ "paragraph",
+ "h1",
+ "h2",
+ "h3",
+ "h4",
+ "h5",
+ "h6",
+ "strong",
+ "em",
+ "strikethrough",
+ "underline",
+ "link",
+ "code",
+ "blockquote",
+ "list",
+ "codeBlock",
+ "thematicBreak",
+ "image",
+ "inlineImage",
+ "video",
+ "table",
+ "taskList",
+ "math",
+ "inlineMath",
+ "spoiler",
+ "superscript",
+ "subscript",
+ "highlight",
+ ).forEach { styles.putMap(it, base) }
+ styles.putArray("linkVariants", JavaOnlyArray())
+ return StyleConfig(styles, context, allowFontScaling = false, maxFontSizeMultiplier = 1f)
+ }
+
+ private fun measureTextView(
+ text: CharSequence,
+ fontSizePx: Float,
+ widthPx: Int,
+ ): EnrichedMarkdownInternalText {
+ val context = RuntimeEnvironment.getApplication()
+ return EnrichedMarkdownInternalText(context).apply {
+ setTextSize(TypedValue.COMPLEX_UNIT_PX, fontSizePx)
+ breakStrategy = Layout.BREAK_STRATEGY_HIGH_QUALITY
+ applyStyledText(text)
+ measure(
+ MeasureSpec.makeMeasureSpec(widthPx, MeasureSpec.EXACTLY),
+ MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED),
+ )
+ }
+ }
+
+ @Test
+ fun listNestedBlockquotesMatchMeasurementAndKeepSpacerHeights() {
+ val context = RuntimeEnvironment.getApplication()
+ val style = styleConfig()
+ val widthPx = 640
+ val fontSizePx = style.paragraphStyle.fontSize
+
+ val ast =
+ MarkdownASTNode(
+ NodeType.Document,
+ children =
+ listOf(
+ MarkdownASTNode(
+ NodeType.OrderedList,
+ attributes = mapOf("start" to "1"),
+ children =
+ listOf(
+ MarkdownASTNode(
+ NodeType.ListItem,
+ children =
+ listOf(
+ MarkdownASTNode(NodeType.Paragraph, children = listOf(MarkdownASTNode(NodeType.Text, "First item"))),
+ MarkdownASTNode(
+ NodeType.Blockquote,
+ children =
+ listOf(
+ MarkdownASTNode(NodeType.Paragraph, children = listOf(MarkdownASTNode(NodeType.Text, "First quote"))),
+ ),
+ ),
+ ),
+ ),
+ MarkdownASTNode(
+ NodeType.ListItem,
+ children =
+ listOf(
+ MarkdownASTNode(NodeType.Paragraph, children = listOf(MarkdownASTNode(NodeType.Text, "Second item"))),
+ MarkdownASTNode(
+ NodeType.Blockquote,
+ children =
+ listOf(
+ MarkdownASTNode(NodeType.Paragraph, children = listOf(MarkdownASTNode(NodeType.Text, "Second quote"))),
+ ),
+ ),
+ ),
+ ),
+ ),
+ ),
+ MarkdownASTNode(NodeType.Paragraph, children = listOf(MarkdownASTNode(NodeType.Text, "Trailing paragraph"))),
+ ),
+ )
+
+ val renderer = Renderer().apply { configure(style, context) }
+ val rendered = renderer.renderDocument(ast)
+
+ val storeLayout = MeasurementStore.createStaticLayout(rendered, fontSizePx, widthPx, null)
+ val segmentLayout =
+ SegmentHeightMeasurer.createStaticLayout(rendered, fontSizePx, widthPx, Layout.BREAK_STRATEGY_HIGH_QUALITY)
+ val textView = measureTextView(rendered, fontSizePx, widthPx)
+
+ assertEquals("MeasurementStore and TextView must agree on height", textView.measuredHeight, storeLayout.height)
+ assertEquals("SegmentHeightMeasurer and TextView must agree on height", textView.measuredHeight, segmentLayout.height)
+
+ // Verify blockquote top-padding and bottom-margin spacer lines keep their configured
+ // heights instead of being inflated to list.lineHeight (22dp).
+ val paddingPx = style.blockquoteStyle.padding.toInt()
+ val marginBottomPx = style.blockquoteStyle.marginBottom.toInt()
+ val itemSpacingPx = style.listStyle.itemSpacing.toInt()
+ val spacerLineHeights =
+ (0 until storeLayout.lineCount)
+ .filter { line ->
+ val start = storeLayout.getLineStart(line)
+ val end = storeLayout.getLineEnd(line)
+ end - start == 1 && rendered[start] == '\n'
+ }.map { line -> storeLayout.getLineBottom(line) - storeLayout.getLineTop(line) }
+
+ assertEquals(
+ listOf(paddingPx, marginBottomPx + itemSpacingPx, paddingPx, marginBottomPx, marginBottomPx),
+ spacerLineHeights,
+ )
+ }
+
+ @Test
+ fun measurementStaticLayoutUsesInsertionOrderLikeTextView() {
+ val context = RuntimeEnvironment.getApplication()
+ DisplayMetricsHolder.initDisplayMetricsIfNotInitialized(context)
+ val widthPx = 400
+ val fontSizePx = 16f
+
+ // Inner priority-0 spacer inserted before outer priority-0 LineHeightSpan:
+ // SpannableStringBuilder's unsorted fast path orders by start offset (outer first),
+ // while InsertionOrderedSpannable orders by insertion order (inner first, so outer inflates it).
+ val builder = SpannableStringBuilder("first\n\nsecond")
+ builder.setSpan(
+ object : AndroidLineHeightSpan {
+ override fun chooseHeight(
+ text: CharSequence,
+ start: Int,
+ end: Int,
+ spanstartv: Int,
+ v: Int,
+ fm: Paint.FontMetricsInt,
+ ) {
+ fm.top = 0
+ fm.ascent = 0
+ fm.descent = 12
+ fm.bottom = 12
+ }
+ },
+ 6,
+ 7,
+ SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE,
+ )
+ builder.setSpan(LineHeightSpan(40f), 0, builder.length, SPAN_FLAGS_EXCLUSIVE_EXCLUSIVE)
+
+ val storeLayout = MeasurementStore.createStaticLayout(builder, fontSizePx, widthPx, null)
+ val segmentLayout =
+ SegmentHeightMeasurer.createStaticLayout(builder, fontSizePx, widthPx, Layout.BREAK_STRATEGY_HIGH_QUALITY)
+ val textView = measureTextView(builder, fontSizePx, widthPx)
+
+ assertEquals(textView.measuredHeight, storeLayout.height)
+ assertEquals(textView.measuredHeight, segmentLayout.height)
+ }
+}
@@ -152,92 +152,18 @@ index 8d78aea..b84d19e 100644
viewGroup: ViewGroup,
coords: FloatArray,
diff --git a/node_modules/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerRootHelper.kt b/node_modules/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerRootHelper.kt
index 629c155..2efd508 100644
index 629c155..dc0790d 100644
--- a/node_modules/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerRootHelper.kt
+++ b/node_modules/react-native-gesture-handler/android/src/main/java/com/swmansion/gesturehandler/react/RNGestureHandlerRootHelper.kt
@@ -19,7 +19,9 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
@@ -19,6 +19,7 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
private val jsGestureHandler: GestureHandler?
val rootView: ViewGroup
private var shouldIntercept = false
+ private var wasIntercepting = false
private var passingTouch = false
+ private var lastTouch: MotionEvent? = null
init {
UiThreadUtil.assertOnUiThread()
@@ -47,6 +49,7 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
}
fun tearDown() {
+ clearLastTouch()
Log.i(
ReactConstants.TAG,
"[GESTURE HANDLER] Tearing down gesture handler registered for root view $rootView",
@@ -90,17 +93,46 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
override fun onCancel() {
shouldIntercept = true
- val time = SystemClock.uptimeMillis()
- val event = MotionEvent.obtain(time, time, MotionEvent.ACTION_CANCEL, 0f, 0f, 0).apply {
- action = MotionEvent.ACTION_CANCEL
- }
if (rootView is RootView) {
- rootView.onChildStartedNativeGesture(rootView, event)
+ val cancel = createReactCancelEvent()
+ try {
+ rootView.onChildStartedNativeGesture(rootView, cancel)
+ } finally {
+ cancel.recycle()
+ clearLastTouch()
+ }
}
- event.recycle()
}
}
+ private fun clearLastTouch() {
+ lastTouch?.recycle()
+ lastTouch = null
+ }
+
+ private fun createReactCancelEvent(): MotionEvent {
+ val now = SystemClock.uptimeMillis()
+ val touch = lastTouch ?: return MotionEvent.obtain(now, now, MotionEvent.ACTION_CANCEL, 0f, 0f, 0)
+ // The enclosing React root already dispatched this event before it reached the
+ // gesture handler. A POINTER_UP is still in MotionEvent but already ended in JS.
+ val lifted = if (touch.actionMasked == MotionEvent.ACTION_POINTER_UP) touch.actionIndex else -1
+ val count = touch.pointerCount - if (lifted >= 0) 1 else 0
+ val properties = Array(count) { MotionEvent.PointerProperties() }
+ val coords = Array(count) { MotionEvent.PointerCoords() }
+ var index = 0
+ for (pointer in 0 until touch.pointerCount) {
+ if (pointer == lifted) continue
+ touch.getPointerProperties(pointer, properties[index])
+ touch.getPointerCoords(pointer, coords[index])
+ index++
+ }
+ return MotionEvent.obtain(
+ touch.downTime, now, MotionEvent.ACTION_CANCEL, count, properties, coords,
+ touch.metaState, touch.buttonState, touch.xPrecision, touch.yPrecision,
+ touch.deviceId, touch.edgeFlags, touch.source, touch.flags,
+ )
+ }
+
fun requestDisallowInterceptTouchEvent() {
// If this method gets called it means that some native view is attempting to grab lock for
// touch event delivery. In that case we cancel all gesture recognizers
@@ -115,9 +147,25 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
// We mark `mPassingTouch` before we get into `mOrchestrator.onTouchEvent` so that we can tell
// if `requestDisallow` has been called as a result of a normal gesture handling process or
// as a result of one of the gesture handlers activating
+ // Keep the stream for recognizers that activate between events (e.g. long press).
+ // Once native handling begins, React no longer receives the remaining touches.
+ if (!event.isHoverAction() && (!shouldIntercept || event.actionMasked == MotionEvent.ACTION_DOWN)) {
+ clearLastTouch()
+ if (event.actionMasked != MotionEvent.ACTION_UP && event.actionMasked != MotionEvent.ACTION_CANCEL) {
+ lastTouch = MotionEvent.obtainNoHistory(event)
+ }
+ }
@@ -118,6 +119,14 @@ class RNGestureHandlerRootHelper(private val context: ReactContext, wrappedView:
passingTouch = true
orchestrator!!.onTouchEvent(event)
passingTouch = false
+22
View File
@@ -0,0 +1,22 @@
# 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
Use [Worktrunk v0.82.0](https://github.com/max-sixty/worktrunk/releases/tag/v0.82.0) with Git 2.43.0 or later on the daemon host.
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
```
+44
View File
@@ -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" }
}
+317
View File
@@ -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.
}
}
@@ -213,3 +213,156 @@ describe("installation", () => {
).resolves.toEqual({ status: "not_installed" });
});
});
it("keeps a turn open for backgrounded run_command calls but not IsDaemon commands", async () => {
const { directory, launch } = await launchAgent(`
const { createInterface } = require("node:readline");
const send = (message) => process.stdout.write(JSON.stringify({ jsonrpc: "2.0", ...message }) + "\\n");
let turn = 0;
createInterface({ input: process.stdin }).on("line", (line) => {
const { id, method, params } = JSON.parse(line);
switch (method) {
case "initialize":
send({ id, result: { protocolVersion: 1, agentCapabilities: {} } });
break;
case "session/new":
send({ id, result: { sessionId: "agy-session", configOptions: [
{ id: "mode", name: "Mode", category: "mode", type: "select", currentValue: "default",
options: [{ value: "default", name: "Default" }] },
] } });
break;
case "session/prompt":
turn += 1;
if (turn === 1) {
send({ method: "session/update", params: { sessionId: params.sessionId, update: {
sessionUpdate: "tool_call", toolCallId: "daemon-1", name: "run_command",
title: "Dev server", status: "in_progress", rawInput: { CommandLine: "npm run dev", IsDaemon: true },
} } });
send({ id, result: { stopReason: "end_turn" } });
} else {
send({ method: "session/update", params: { sessionId: params.sessionId, update: {
sessionUpdate: "tool_call", toolCallId: "bg-1", name: "run_command",
title: "Background build", status: "in_progress", rawInput: { CommandLine: "sleep 1" },
} } });
send({ id, result: { stopReason: "end_turn" } });
setTimeout(() => {
send({ method: "session/update", params: { sessionId: params.sessionId, update: {
sessionUpdate: "tool_call_update", toolCallId: "bg-1", status: "completed",
} } });
send({ method: "session/update", params: { sessionId: params.sessionId, update: {
sessionUpdate: "agent_message_chunk", content: { type: "text", text: "Build finished." },
} } });
send({ method: "session/update", params: { sessionId: params.sessionId, update: {
sessionUpdate: "usage_update", used: 50, size: 1000,
} } });
}, 80);
}
break;
case "session/close":
send({ id, result: {} });
break;
}
});
`);
const provider = createAntigravityProvider();
const connection = await provider.connect({
launch,
versions: [1],
capabilities: ["prompt.message"],
});
const events: ProviderEvent[] = [];
connection.onEvent((event) => events.push(event));
try {
await connection.send({
type: "session.open",
requestId: "open-1",
sessionId: "agy-test",
history: "skip",
config: {
cwd: directory,
env: {},
mcpServers: {},
settings: {},
persist: false,
},
});
await expect
.poll(() => events.find((event) => event.type === "session.ready"), { timeout: 3_000 })
.toBeDefined();
// Turn 1: IsDaemon: true completes immediately on end_turn.
await connection.send({
type: "session.prompt",
sessionId: "agy-test",
prompt: {
clientMessageId: "daemon-turn",
delivery: "auto",
input: { type: "message", content: [{ type: "text", text: "start dev server" }] },
},
});
await expect
.poll(
() =>
events.find(
(event) =>
event.type === "session.turn" &&
event.turnId === "acp:daemon-turn" &&
event.state === "completed",
),
{ timeout: 3_000 },
)
.toBeDefined();
// Turn 2: non-daemon background command keeps turn open until completion + reply + usage_update.
await connection.send({
type: "session.prompt",
sessionId: "agy-test",
prompt: {
clientMessageId: "bg-turn",
delivery: "auto",
input: { type: "message", content: [{ type: "text", text: "run build" }] },
},
});
await expect
.poll(
() =>
events.find(
(event) =>
event.type === "timeline.item" &&
event.item.type === "tool_call" &&
event.item.id === "bg-1" &&
event.item.status === "running",
),
{ timeout: 3_000 },
)
.toBeDefined();
expect(
events.some(
(event) =>
event.type === "session.turn" &&
event.turnId === "acp:bg-turn" &&
event.state === "completed",
),
).toBe(false);
await expect
.poll(
() =>
events.find(
(event) =>
event.type === "session.turn" &&
event.turnId === "acp:bg-turn" &&
event.state === "completed",
),
{ timeout: 3_000 },
)
.toBeDefined();
expect(events).toContainEqual(
expect.objectContaining({
type: "timeline.item",
item: expect.objectContaining({ type: "assistant_message", text: "Build finished." }),
}),
);
} finally {
await connection.close();
}
});
@@ -95,6 +95,16 @@ export function createAntigravityProvider(): ProviderRegistration {
acpOptions: {
waitForInitialCommands: true,
loadReplayQuietPeriodMs: 200,
// COMPAT(antigravityAcpV1DeferredTurn): added in v0.18.0, remove once Antigravity CLI supports ACP v2 state_update.
deferTurnOnRunningTools: {
keepsTurnOpen(toolCall) {
const input = toolCall.input;
if (typeof input === "object" && input !== null && !Array.isArray(input)) {
return input.IsDaemon !== true;
}
return true;
},
},
autoAcceptMode: {
mode: {
id: "full-access",
+2 -1
View File
@@ -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`.
+8 -7
View File
@@ -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 的输出。
+108
View File
@@ -696,6 +696,114 @@ 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`.
All managers share 120 seconds for each create request. Return `{ type: "created", path }` to
claim creation. If you return `undefined`, Paseo tries the next manager or uses built-in Git.
For branch-off, Paseo resolves `baseRef` and refreshes a remote-tracking starting ref before
calling the manager. If the fetch fails, Paseo uses the cached ref. 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 and falls back to Git when that plugin is disabled or uninstalled.
Paseo keeps the directory if it contains another linked Git worktree. Standalone clones and
submodules follow normal removal. During archive, an active workspace nested inside the directory
also keeps it on disk. If the callback throws or times out after 120 seconds, Paseo skips Git
fallback. During archive, Paseo logs the callback failure and still archives the workspace.
Any files the callback left stay on disk.
- **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
+78
View File
@@ -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 移除剩余的注册之前运行。
+11
View File
@@ -82,6 +82,17 @@ const patchedPackages = [
patchPrefix: "react-native-svg+",
cwd: "packages/app",
},
// Reconcile ResponderEventPlugin trackedTouchCount and ResponderTouchHistoryStore touchBank with
// nativeEvent.touches.length so an unmatched touch start or single-pointer synthetic cancel
// (e.g. Modal dismiss while touching, RNGH pinch takeover, or double ACTION_DOWN in
// ReactRootView/ReactModalHostView) self-heals instead of leaving trackedTouchCount > 0 or stale
// active contacts in touchBank. Remove once upstream React/React Native reconciles both.
{
nodeModulesPath: "node_modules/react-native",
patchPrefix: "react-native+",
},
// Keep Android PasteTextInput aligned with RN AndroidTextInput (omit iOS-only
// onSelectionChangeShouldSetResponder), plus ref/eventCount/trailing-newline fixes.
{
nodeModulesPath: "node_modules/@mattermost/react-native-paste-input",
patchPrefix: "@mattermost+react-native-paste-input+",
+289
View File
@@ -1,9 +1,11 @@
import assert from "node:assert/strict";
import { spawnSync } from "node:child_process";
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { createRequire } from "node:module";
import { tmpdir } from "node:os";
import path from "node:path";
import { test } from "node:test";
import vm from "node:vm";
const script = path.resolve("scripts", "postinstall-patches.mjs");
const bin = path.resolve("node_modules", ".bin");
@@ -134,3 +136,290 @@ test("a missing patch-package fails the install and leaves the package in place"
rmSync(root, { recursive: true, force: true });
}
});
function loadReactFabricDispatchEvent(bundleName, isDev) {
const bundlePath = path.resolve(
"node_modules/react-native/Libraries/Renderer/implementations",
bundleName,
);
const code = readFileSync(bundlePath, "utf8");
const nodeRequire = createRequire(import.meta.url);
let dispatchEvent = null;
const warnings = [];
const rawEventListeners = new Map();
const nativeFabricUIManager = {
createNode: () => ({}),
cloneNodeWithNewChildren: () => ({}),
cloneNodeWithNewChildrenAndProps: () => ({}),
cloneNodeWithNewProps: () => ({}),
createChildSet: () => ({}),
appendChild: () => {},
appendChildToSet: () => {},
completeRoot: () => {},
registerEventHandler: (fn) => {
dispatchEvent = fn;
},
setIsJSResponder: () => {},
clearIsJSResponder: () => {},
unstable_DiscreteEventPriority: 1,
unstable_ContinuousEventPriority: 2,
unstable_IdleEventPriority: 3,
unstable_getCurrentEventPriority: () => 1,
};
const privateInterface = {
ReactNativeViewConfigRegistry: {
get: () => ({}),
customBubblingEventTypes: {
topTouchStart: {
phasedRegistrationNames: { bubbled: "onTouchStart", captured: "onTouchStartCapture" },
},
topTouchMove: {
phasedRegistrationNames: { bubbled: "onTouchMove", captured: "onTouchMoveCapture" },
},
topTouchEnd: {
phasedRegistrationNames: { bubbled: "onTouchEnd", captured: "onTouchEndCapture" },
},
topTouchCancel: {
phasedRegistrationNames: { bubbled: "onTouchCancel", captured: "onTouchCancelCapture" },
},
topSelectionChange: {
phasedRegistrationNames: {
bubbled: "onSelectionChange",
captured: "onSelectionChangeCapture",
},
},
},
customDirectEventTypes: {},
},
RawEventEmitter: {
emit: (name, payload) => {
for (const fn of rawEventListeners.get(name) ?? []) {
fn(payload);
}
},
},
UIManager: {},
deepDiffer: () => false,
flattenStyle: (s) => s,
getNativeTagFromPublicInstance: () => null,
getNodeFromPublicInstance: () => null,
legacySendAccessibilityEvent: () => {},
createPublicInstance: (tag) => ({ _nativeTag: tag }),
createPublicTextInstance: () => ({}),
ReactFiberErrorDialog: { showErrorDialog: () => true },
Platform: { OS: "android" },
};
const customRequire = (id) => {
if (id === "react") {
return nodeRequire("react");
}
if (id === "scheduler") {
return nodeRequire("scheduler");
}
if (id === "react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore") {
return {};
}
if (id === "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface") {
return privateInterface;
}
return nodeRequire(id);
};
const moduleObj = { exports: {} };
const sandbox = {
__DEV__: isDev,
console: {
...console,
warn: (...args) => warnings.push(args.join(" ")),
error: (...args) => warnings.push(args.join(" ")),
},
exports: moduleObj.exports,
module: moduleObj,
nativeFabricUIManager,
performance,
queueMicrotask,
require: customRequire,
setTimeout,
clearTimeout,
};
sandbox.global = sandbox;
sandbox.globalThis = sandbox;
vm.runInNewContext(code, sandbox, { filename: bundleName });
assert.equal(
typeof dispatchEvent,
"function",
`Expected ${bundleName} to register dispatchEvent`,
);
return { dispatchEvent, warnings };
}
function createHostFiber(type, props, parent = null) {
const publicInstance = { _nativeTag: Math.floor(Math.random() * 100000) + 1 };
return {
tag: 5,
type,
return: parent,
alternate: null,
stateNode: {
canonical: {
currentProps: props,
publicInstance,
publicInstanceType: 0,
},
},
};
}
function makeTouch(identifier, timestamp) {
return {
identifier,
target: 1,
pageX: 100,
pageY: 100,
locationX: 10,
locationY: 10,
timestamp,
};
}
for (const [bundleName, isDev] of [
["ReactFabric-dev.js", true],
["ReactFabric-prod.js", false],
["ReactFabric-profiling.js", false],
]) {
test(`${bundleName} reconciles trackedTouchCount from nativeEvent.touches after a dropped touch end`, () => {
const { dispatchEvent, warnings } = loadReactFabricDispatchEvent(bundleName, isDev);
const rootFiber = createHostFiber("RCTView", {});
let inputGrants = 0;
let buttonGrants = 0;
const inputFiber = createHostFiber(
"PasteTextInput",
{
onSelectionChangeShouldSetResponder: () => true,
onResponderGrant: () => {
inputGrants += 1;
},
},
rootFiber,
);
const buttonFiber = createHostFiber(
"RCTView",
{
onStartShouldSetResponder: () => true,
onResponderGrant: () => {
buttonGrants += 1;
},
},
rootFiber,
);
// 1. Unmatched touch start (e.g. Modal dismissed while touch is down or double ACTION_DOWN).
const orphanTouch = makeTouch(0, 1);
dispatchEvent(rootFiber, "topTouchStart", {
touches: [orphanTouch],
changedTouches: [orphanTouch],
});
// 2. Subsequent normal tap completes with zero remaining native touches.
const tapTouch = makeTouch(1, 2);
dispatchEvent(inputFiber, "topTouchStart", {
touches: [tapTouch],
changedTouches: [tapTouch],
});
dispatchEvent(inputFiber, "topTouchEnd", {
touches: [],
changedTouches: [tapTouch],
});
// 3. Typing triggers topSelectionChange. With trackedTouchCount reconciled to 0,
// the input must not claim responder and swallow the next tap on a sibling button.
dispatchEvent(inputFiber, "topSelectionChange", {
selection: { start: 1, end: 1 },
});
assert.equal(
inputGrants,
0,
"topSelectionChange must not claim responder when no touches are active",
);
// 4. First tap on sibling send button must be granted immediately.
const sendTouch = makeTouch(2, 3);
dispatchEvent(buttonFiber, "topTouchStart", {
touches: [sendTouch],
changedTouches: [sendTouch],
});
dispatchEvent(buttonFiber, "topTouchEnd", {
touches: [],
changedTouches: [sendTouch],
});
assert.equal(buttonGrants, 1, "first tap on sibling button must receive responder grant");
// 5. Two-finger gesture cancelled by a single synthetic topTouchCancel (e.g. RNGH pinch takeover)
// must reconcile trackedTouchCount to 0 and mark every touchBank contact inactive before
// onResponderTerminate runs.
let terminatedHistory = null;
const gestureFiber = createHostFiber(
"RCTView",
{
onStartShouldSetResponder: () => true,
onResponderTerminate: (event) => {
terminatedHistory = {
numberActiveTouches: event.touchHistory.numberActiveTouches,
activeBankIds: Array.from(event.touchHistory.touchBank, (record, index) =>
record?.touchActive ? index : -1,
).filter((index) => index >= 0),
};
},
},
rootFiber,
);
const p0 = makeTouch(3, 4);
const p1 = makeTouch(4, 5);
dispatchEvent(gestureFiber, "topTouchStart", { touches: [p0], changedTouches: [p0] });
dispatchEvent(gestureFiber, "topTouchStart", { touches: [p0, p1], changedTouches: [p1] });
dispatchEvent(gestureFiber, "topTouchCancel", { touches: [], changedTouches: [p0] });
assert.deepEqual(terminatedHistory, {
numberActiveTouches: 0,
activeBankIds: [],
});
dispatchEvent(inputFiber, "topSelectionChange", { selection: { start: 2, end: 2 } });
assert.equal(
inputGrants,
0,
"single topTouchCancel after 2-finger touch must reset trackedTouchCount to 0",
);
// 6. Multi-touch cancel emitting two topTouchCancel events with touches: [] must stay at 0 without warning.
const t0 = makeTouch(5, 6);
const t1 = makeTouch(6, 7);
dispatchEvent(rootFiber, "topTouchStart", { touches: [t0], changedTouches: [t0] });
dispatchEvent(rootFiber, "topTouchStart", { touches: [t0, t1], changedTouches: [t1] });
dispatchEvent(rootFiber, "topTouchCancel", { touches: [], changedTouches: [t0, t1] });
dispatchEvent(rootFiber, "topTouchCancel", { touches: [], changedTouches: [t0, t1] });
dispatchEvent(inputFiber, "topSelectionChange", { selection: { start: 3, end: 3 } });
assert.equal(inputGrants, 0, "multi-touch cancel must leave trackedTouchCount at 0");
assert.deepEqual(
warnings.filter((w) => w.includes("trackedTouchCount")),
[],
);
});
}
test("patched @mattermost/react-native-paste-input Android PasteTextInput does not claim responder on selection change", () => {
for (const relPath of [
"node_modules/@mattermost/react-native-paste-input/src/PasteTextInput.tsx",
"node_modules/@mattermost/react-native-paste-input/lib/commonjs/PasteTextInput.js",
"node_modules/@mattermost/react-native-paste-input/lib/module/PasteTextInput.js",
]) {
const source = readFileSync(path.resolve(relPath), "utf8");
assert.equal(
source.includes("onSelectionChangeShouldSetResponder"),
false,
`${relPath} must not set onSelectionChangeShouldSetResponder (matches RN AndroidTextInput)`,
);
}
});