@camerontaylor/paseo-client 0.8.0-fork.1 → 0.8.0-fork.3

package/dist/connection/index.d.ts

@@ -1,5 +1,28 @@
-import type { SessionEventSubscription } from "@camerontaylor/paseo-protocol/messages";
+export { OwnedSubscriptions, type OwnedSubscription, type SubscriptionObserver } from "./owned.js";
+import { OwnedSubscriptions, type OwnedSubscription, type OwnedSubscriptionsHost } from "./owned.js";
+import { type ObservationRequest } from "./legacy.js";
+import { type SessionInboundMessage, type SessionOutboundMessage, type ServerInfoStatusPayload } from "@camerontaylor/paseo-protocol/messages";
+import { type ClientCapability } from "@camerontaylor/paseo-protocol/client-capabilities";
+export declare class ConnectionSubscriptions extends OwnedSubscriptions {
+    private readonly connection;
+    private legacy;
+    constructor(connection: OwnedSubscriptionsHost & {
+        send(message: ObservationRequest): Promise<void>;
+    });
+    restore(info?: ServerInfoStatusPayload, capabilities?: Partial<Record<ClientCapability, unknown>>): void;
+    disconnected(): void;
+    observeRequest<T>(query: ObservationRequest, request: (query: ObservationRequest, accept: (snapshot: T) => void) => Promise<T>, signal?: AbortSignal, failed?: () => void): OwnedSubscription<T>;
+    owns(message: SessionOutboundMessage): boolean;
+    receive(message: SessionOutboundMessage): void;
+    normalize(message: SessionOutboundMessage): SessionOutboundMessage;
+    prepareRequest(message: SessionInboundMessage): {
+        message: SessionInboundMessage;
+        receive(message: SessionOutboundMessage): SessionOutboundMessage;
+        finish(): Promise<void>;
+    };
+}
 export declare const DEFAULT_CLIENT_CAPABILITIES: {
+    owned_subscriptions: true;
     all_providers: true;
     selective_agent_timeline: true;
     reasoning_merge_enum: true;
@@ -16,27 +39,10 @@ export declare const DEFAULT_CLIENT_CAPABILITIES: {
     workspace_setup_blocked: true;
     explicit_event_subscriptions: true;
 };
-/** Calling releases demand; ready acknowledges the initial daemon membership. */
+/** Calling releases demand; ready waits for membership, or local attachment on broadcast hosts. */
 export type TimelineSubscription = (() => void) & {
     readonly ready: Promise<void>;
+    readonly subscriptionId: string | null;
+    release(): Promise<void>;
 };
-/** Owns connection demand, independently of individual facades and React lifetimes. */
-export declare class ConnectionSubscriptions {
-    private readonly send;
-    private viewed;
-    private timelines;
-    private events;
-    constructor(send: {
-        timelines(agentIds: string[]): Promise<void> | null;
-        events(events: SessionEventSubscription[]): Promise<void>;
-        failed(error: unknown): void;
-    });
-    private agentIds;
-    setViewed(agentIds: string[]): Promise<void>;
-    observeTimeline(agentId: string): TimelineSubscription;
-    private syncTimelines;
-    setEvents(events: SessionEventSubscription[]): void;
-    restore(): void;
-    close(): void;
-}
 //# sourceMappingURL=index.d.ts.map

package/dist/connection/index.js

@@ -1,7 +1,96 @@
+export { OwnedSubscriptions } from "./owned.js";
+import { OwnedSubscriptions, } from "./owned.js";
+import { LegacySubscriptions } from "./legacy.js";
 import { CLIENT_CAPS } from "@camerontaylor/paseo-protocol/client-capabilities";
+export class ConnectionSubscriptions extends OwnedSubscriptions {
+    constructor(connection) {
+        super({
+            ...connection,
+            release: async (id) => {
+                if (!this.legacy)
+                    return connection.release(id);
+                const message = this.legacy.release(id);
+                if (message)
+                    await connection.send(message);
+            },
+        });
+        this.connection = connection;
+        this.legacy = null;
+    }
+    restore(info, capabilities) {
+        if (info) {
+            const clientCapabilities = capabilities ?? DEFAULT_CLIENT_CAPABILITIES;
+            const owned = info.features?.ownedSubscriptions === true &&
+                clientCapabilities[CLIENT_CAPS.ownedSubscriptions] === true;
+            this.legacy = null;
+            if (!owned) {
+                this.legacy = new LegacySubscriptions(info, this.connection.send, capabilities?.[CLIENT_CAPS.browserHost]);
+            }
+        }
+        super.restore();
+    }
+    disconnected() {
+        super.disconnected();
+        this.legacy = null;
+    }
+    observeRequest(query, request, signal, failed) {
+        return super.observe(async (accept) => {
+            const legacy = this.legacy;
+            if (!legacy)
+                return request(query, accept);
+            const interest = legacy.start(query);
+            const snapshot = (payload) => ({
+                ...payload,
+                subscriptionId: interest.id,
+            });
+            try {
+                const message = legacy.request(interest);
+                if (!message) {
+                    // Broadcast-era hosts have no acknowledgement. Readiness means the
+                    // local listener is attached; no server membership is being claimed.
+                    const value = snapshot({
+                        requestId: interest.id,
+                        ...(query.type === "agent.timeline.set_subscription.request"
+                            ? { agentIds: query.agentIds }
+                            : {}),
+                    });
+                    accept(value);
+                    return value;
+                }
+                return snapshot(await request(message, (payload) => accept(snapshot(payload))));
+            }
+            catch (error) {
+                const release = legacy.release(interest.id);
+                if (release && this.legacy === legacy)
+                    await this.connection.send(release).catch(this.connection.failed);
+                throw error;
+            }
+        }, signal, failed);
+    }
+    owns(message) {
+        return this.legacy ? this.legacy.owns(message) : super.owns(message);
+    }
+    receive(message) {
+        if (this.legacy)
+            this.legacy.receive(message, (update) => super.receive(update));
+        else
+            super.receive(message);
+    }
+    normalize(message) {
+        return this.legacy?.normalize(message) ?? message;
+    }
+    prepareRequest(message) {
+        return (this.legacy?.prepareRequest(message) ?? {
+            message,
+            receive: (value) => value,
+            finish: async () => { },
+        });
+    }
+}
 // Protocol support belongs to the installed client. Only browser hosting needs
 // a resource supplied by the caller. Keep this exhaustive as the protocol evolves.
 export const DEFAULT_CLIENT_CAPABILITIES = {
+    [CLIENT_CAPS.ownedSubscriptions]: true,
     [CLIENT_CAPS.allProviders]: true,
     [CLIENT_CAPS.selectiveAgentTimeline]: true,
     [CLIENT_CAPS.reasoningMergeEnum]: true,
@@ -23,89 +112,4 @@ export const DEFAULT_CLIENT_CAPABILITIES = {
     [CLIENT_CAPS.workspaceSetupBlocked]: true,
     [CLIENT_CAPS.explicitEventSubscriptions]: true,
 };
-class TimelineInterest {
-    constructor() {
-        this.ready = new Promise((resolve, reject) => {
-            this.resolve = resolve;
-            this.reject = reject;
-        });
-        // Readiness is optional for fire-and-forget listeners.
-        void this.ready.catch(() => { });
-    }
-}
-/** Owns connection demand, independently of individual facades and React lifetimes. */
-export class ConnectionSubscriptions {
-    constructor(send) {
-        this.send = send;
-        this.viewed = new Set();
-        this.timelines = new Map();
-        this.events = [];
-    }
-    agentIds() {
-        return [...new Set([...this.viewed, ...this.timelines.keys()])].sort();
-    }
-    setViewed(agentIds) {
-        this.viewed = new Set(agentIds);
-        return this.syncTimelines();
-    }
-    observeTimeline(agentId) {
-        const interests = this.timelines.get(agentId) ?? new Set();
-        const interest = new TimelineInterest();
-        interests.add(interest);
-        this.timelines.set(agentId, interests);
-        // Each caller gets acknowledgement for its own registration, even when an
-        // existing listener first subscribed on an earlier connection.
-        void this.syncTimelines().catch(this.send.failed);
-        let active = true;
-        return Object.assign(() => {
-            if (!active)
-                return;
-            active = false;
-            interest.reject(new Error("Timeline subscription released before it was ready"));
-            interests.delete(interest);
-            if (interests.size === 0) {
-                this.timelines.delete(agentId);
-                void this.syncTimelines().catch(this.send.failed);
-            }
-        }, { ready: interest.ready });
-    }
-    async syncTimelines() {
-        const interests = [];
-        for (const listeners of this.timelines.values()) {
-            for (const interest of listeners)
-                interests.push(interest);
-        }
-        try {
-            const sent = this.send.timelines(this.agentIds());
-            if (!sent)
-                return;
-            await sent;
-            for (const interest of interests)
-                interest.resolve();
-        }
-        catch (error) {
-            for (const interest of interests)
-                interest.reject(error);
-            throw error;
-        }
-    }
-    setEvents(events) {
-        if (JSON.stringify(this.events) === JSON.stringify(events))
-            return;
-        this.events = events;
-        void this.send.events(events).catch(this.send.failed);
-    }
-    restore() {
-        if (this.agentIds().length)
-            void this.syncTimelines().catch(this.send.failed);
-        if (this.events.length)
-            void this.send.events(this.events).catch(this.send.failed);
-    }
-    close() {
-        for (const interests of this.timelines.values()) {
-            for (const interest of interests)
-                interest.reject(new Error("Daemon client closed"));
-        }
-    }
-}
 //# sourceMappingURL=index.js.map

package/dist/connection/legacy-workspaces.d.ts

@@ -0,0 +1,19 @@
+import type { SessionOutboundMessage } from "@camerontaylor/paseo-protocol/messages";
+type AgentEntry = Extract<SessionOutboundMessage, {
+    type: "fetch_agents_response";
+}>["payload"]["entries"][number];
+type Workspace = Extract<SessionOutboundMessage, {
+    type: "fetch_workspaces_response";
+}>["payload"]["entries"][number];
+type WorkspaceUpdate = Extract<SessionOutboundMessage, {
+    type: "workspace_update";
+}>;
+export declare class LegacyWorkspaces {
+    private readonly agents;
+    normalize(message: SessionOutboundMessage): SessionOutboundMessage;
+    read(entries: AgentEntry[], reset: boolean): Workspace[];
+    update(message: SessionOutboundMessage): WorkspaceUpdate[];
+    private workspaces;
+}
+export {};
+//# sourceMappingURL=legacy-workspaces.d.ts.map

package/dist/connection/legacy-workspaces.js

@@ -0,0 +1,160 @@
+import { AgentSnapshotPayloadSchema } from "@camerontaylor/paseo-protocol/messages";
+import { deriveAgentStateBucket, getWorkspaceStateBucketPriority, } from "@camerontaylor/paseo-protocol/agent-state-bucket";
+// Preserve the pre-registry app's identity format. This is an opaque ID, never
+// a filesystem path: converting C:\ to C: changes a drive root into a relative path.
+function legacyWorkspaceId(value) {
+    return value.trim().replace(/\\/g, "/").replace(/\/+$/, "") || "/";
+}
+// COMPAT(legacyWorkspaceDaemon): restored in v0.8.0; remove after 2027-03-11 once daemon floor >= v0.1.97.
+// The pre-registry app grouped agents by checkout path. Keep that representation
+// at the client edge, including live updates, so app workflows need no version branch.
+export class LegacyWorkspaces {
+    constructor() {
+        this.agents = new Map();
+    }
+    normalize(message) {
+        const stamp = (agent) => ({
+            ...agent,
+            workspaceId: agent.workspaceId ?? legacyWorkspaceId(agent.cwd),
+        });
+        if (message.type === "fetch_agents_response")
+            return {
+                ...message,
+                payload: {
+                    ...message.payload,
+                    entries: message.payload.entries.map((entry) => ({
+                        ...entry,
+                        agent: stamp(entry.agent),
+                    })),
+                },
+            };
+        if (message.type === "agent_update" && message.payload.kind === "upsert")
+            return { ...message, payload: { ...message.payload, agent: stamp(message.payload.agent) } };
+        if ((message.type === "fetch_agent_response" ||
+            message.type === "fetch_agent_timeline_response" ||
+            message.type === "cancel_agent_response") &&
+            message.payload.agent) {
+            return {
+                ...message,
+                payload: { ...message.payload, agent: stamp(message.payload.agent) },
+            };
+        }
+        if (message.type === "status" &&
+            (message.payload.status === "agent_created" || message.payload.status === "agent_resumed")) {
+            return {
+                ...message,
+                payload: {
+                    ...message.payload,
+                    agent: stamp(AgentSnapshotPayloadSchema.parse(message.payload.agent)),
+                },
+            };
+        }
+        return message;
+    }
+    read(entries, reset) {
+        if (reset)
+            this.agents.clear();
+        for (const entry of entries)
+            this.agents.set(entry.agent.id, entry);
+        const pageIds = new Set(entries.map(workspaceId));
+        return [...this.workspaces().values()].filter((workspace) => pageIds.has(workspace.id));
+    }
+    update(message) {
+        if (message.type !== "agent_update")
+            return [];
+        const before = this.workspaces();
+        const update = message.payload;
+        if (update.kind === "remove")
+            this.agents.delete(update.agentId);
+        else {
+            const project = update.project ?? this.agents.get(update.agent.id)?.project;
+            if (update.agent.archivedAt)
+                this.agents.delete(update.agent.id);
+            else if (project)
+                this.agents.set(update.agent.id, { agent: update.agent, project });
+        }
+        const after = this.workspaces();
+        const changes = [];
+        for (const [id, workspace] of after) {
+            if (JSON.stringify(before.get(id)) !== JSON.stringify(workspace))
+                changes.push({ type: "workspace_update", payload: { kind: "upsert", workspace } });
+        }
+        for (const id of before.keys())
+            if (!after.has(id))
+                changes.push({ type: "workspace_update", payload: { kind: "remove", id } });
+        return changes;
+    }
+    workspaces() {
+        const workspaces = new Map();
+        for (const entry of this.agents.values()) {
+            const { agent, project } = entry;
+            const { checkout } = project;
+            const id = workspaceId(entry);
+            const status = deriveAgentStateBucket({
+                status: agent.status,
+                pendingPermissionCount: agent.pendingPermissions.length,
+                requiresAttention: agent.requiresAttention,
+                attentionReason: agent.attentionReason,
+            });
+            const existing = workspaces.get(id);
+            if (existing &&
+                getWorkspaceStateBucketPriority(existing.status) <= getWorkspaceStateBucketPriority(status))
+                continue;
+            workspaces.set(id, {
+                id,
+                projectId: project.projectKey,
+                projectDisplayName: project.projectName,
+                projectCustomName: null,
+                projectRootPath: checkout.mainRepoRoot ?? checkout.worktreeRoot ?? checkout.cwd,
+                workspaceDirectory: checkout.cwd,
+                projectKind: checkout.isGit ? "git" : "non_git",
+                workspaceKind: workspaceKind(checkout),
+                name: workspaceName(entry, id),
+                title: null,
+                status,
+                statusEnteredAt: agent.attentionTimestamp ?? agent.updatedAt,
+                activityAt: agent.updatedAt,
+                archivingAt: null,
+                diffStat: null,
+                scripts: [],
+                gitRuntime: gitRuntime(checkout),
+                githubRuntime: null,
+                project,
+            });
+        }
+        return workspaces;
+    }
+}
+function workspaceId(entry) {
+    return entry.agent.workspaceId ?? legacyWorkspaceId(entry.project.checkout.cwd);
+}
+function workspaceKind(checkout) {
+    if (!checkout.isGit)
+        return "directory";
+    if (checkout.isPaseoOwnedWorktree)
+        return "worktree";
+    return "checkout";
+}
+function workspaceName(entry, id) {
+    const name = entry.project.workspaceName?.trim();
+    if (name)
+        return name;
+    const branch = entry.project.checkout.currentBranch?.trim();
+    if (branch && branch !== "HEAD")
+        return branch;
+    return id.slice(id.lastIndexOf("/") + 1);
+}
+function gitRuntime(checkout) {
+    if (!checkout.isGit)
+        return null;
+    return {
+        currentBranch: checkout.currentBranch,
+        remoteUrl: checkout.remoteUrl,
+        isPaseoOwnedWorktree: checkout.isPaseoOwnedWorktree,
+        isDirty: null,
+        aheadBehind: null,
+        aheadOfOrigin: null,
+        behindOfOrigin: null,
+    };
+}
+//# sourceMappingURL=legacy-workspaces.js.map

package/dist/connection/legacy.d.ts

@@ -0,0 +1,31 @@
+import type { ServerInfoStatusPayload, SessionInboundMessage, SessionOutboundMessage } from "@camerontaylor/paseo-protocol/messages";
+export type ObservationRequest = {
+    type: SessionInboundMessage["type"];
+} & Record<string, unknown>;
+interface Interest {
+    id: string;
+    query: ObservationRequest;
+}
+export declare class LegacySubscriptions {
+    private readonly info;
+    private readonly send;
+    private readonly browserHost;
+    private readonly interests;
+    private readonly workspaces;
+    constructor(info: ServerInfoStatusPayload, send: (message: ObservationRequest) => Promise<void>, browserHost: unknown);
+    normalize(message: SessionOutboundMessage): SessionOutboundMessage;
+    prepareRequest(message: SessionInboundMessage): {
+        message: SessionInboundMessage;
+        receive(message: SessionOutboundMessage): SessionOutboundMessage;
+        finish(): Promise<void>;
+    };
+    start(query: ObservationRequest): Interest;
+    request({ id, query }: Interest): ObservationRequest | null;
+    private members;
+    release(id: string): ObservationRequest | null;
+    owns(message: SessionOutboundMessage): boolean;
+    receive(message: SessionOutboundMessage, deliver: (message: SessionOutboundMessage) => void): void;
+    private matches;
+}
+export {};
+//# sourceMappingURL=legacy.d.ts.map