@cjhyy/code-shell-pet 0.8.0

package/dist/projection-extension.js

@@ -0,0 +1,238 @@
+import { GET_PET_PROJECTION_SNAPSHOT_METHOD, PET_PROJECTION_DELTA_METHOD, } from "./protocol.js";
+import { PendingDecisionIndex } from "./pending-decision-index.js";
+import { SessionIndex } from "./session-index.js";
+import { LOCAL_PET_OWNER, } from "./types.js";
+/** Session kinds owned by the pet domain — hidden from generic session lists. */
+export const PET_HIDDEN_SESSION_KINDS = ["pet"];
+/**
+ * Build the pet projection observer. All former AgentServer pet state and
+ * methods live here, keyed off the domain-neutral host surface.
+ */
+export function createPetProjectionObserver(host) {
+    const pendingDecisionIndex = new PendingDecisionIndex();
+    const petSessionIndex = new SessionIndex();
+    const petCatalog = new Map();
+    let petProjectionVersion = 0;
+    let petProjectionDisconnected = false;
+    let petProjectionClosing = false;
+    const petWorkerGeneration = () => host.projectionGeneration();
+    const nextPetProjectionVersion = () => {
+        petProjectionVersion += 1;
+        return petProjectionVersion;
+    };
+    const sendPetProjectionDelta = (delta) => {
+        // Socket teardown can resolve a fail-closed approval and finish its run.
+        // Do not write projection tail events to a transport whose owner is gone.
+        if (host.isTransportDisconnected() && !petProjectionClosing)
+            return;
+        host.notify(PET_PROJECTION_DELTA_METHOD, delta);
+    };
+    const ensurePetSession = (sessionId, updatedAt = Date.now()) => {
+        const previous = petCatalog.get(sessionId);
+        petCatalog.set(sessionId, {
+            sessionId,
+            updatedAt: Math.max(previous?.updatedAt ?? 0, updatedAt),
+        });
+        petSessionIndex.replaceCatalog({
+            owner: LOCAL_PET_OWNER,
+            sessions: [...petCatalog.values()],
+            observedAt: updatedAt,
+        });
+    };
+    const currentPetSessionProjection = (sessionId, observedAt) => {
+        const live = host.getLiveSessionSnapshot().find((session) => session.sessionId === sessionId);
+        if (!live || live.kind === "pet")
+            return undefined;
+        ensurePetSession(sessionId, live.lastActivityAt);
+        const indexed = petSessionIndex.get(sessionId);
+        const pendingDecisionCount = pendingDecisionIndex
+            .pendingSnapshot()
+            .filter((entry) => entry.agentSessionId === sessionId).length;
+        const liveRunState = live.busy ? "running" : live.queueDepth > 0 ? "queued" : "idle";
+        const terminal = liveRunState === "idle" ? indexed?.terminal : undefined;
+        const runState = terminal ? "terminal" : liveRunState;
+        return {
+            owner: LOCAL_PET_OWNER,
+            agentSessionId: sessionId,
+            coreSessionId: sessionId,
+            title: indexed?.title,
+            workspaceDisplayName: indexed?.workspaceDisplayName,
+            runState,
+            phase: pendingDecisionCount > 0 ? "waiting-decision" : indexed?.phase,
+            summary: pendingDecisionCount > 0
+                ? pendingDecisionCount === 1
+                    ? "等待用户决定"
+                    : `等待用户决定（${pendingDecisionCount}）`
+                : (indexed?.summary ?? (runState === "running" ? "运行中" : undefined)),
+            queueDepth: live.queueDepth,
+            lastActivityAt: Math.max(live.lastActivityAt, indexed?.lastActivityAt ?? 0),
+            pendingDecisionCount,
+            completionKind: liveRunState === "idle" ? indexed?.completionKind : undefined,
+            terminal,
+            freshness: { source: "live-snapshot", observedAt, workerState: "active" },
+        };
+    };
+    const buildPetProjectionSnapshot = () => {
+        const observedAt = Date.now();
+        const sessions = host
+            .getLiveSessionSnapshot()
+            .filter((session) => session.kind !== "pet")
+            .map((session) => currentPetSessionProjection(session.sessionId, observedAt))
+            .filter((session) => session !== undefined)
+            .sort((a, b) => a.agentSessionId.localeCompare(b.agentSessionId));
+        return {
+            snapshotVersion: petProjectionVersion,
+            workerGeneration: petWorkerGeneration(),
+            observedAt,
+            sessions,
+            pending: pendingDecisionIndex.pendingSnapshot(),
+        };
+    };
+    const recordPetStreamEvent = (sessionId, event) => {
+        const observedAt = Date.now();
+        const live = host.getLiveSessionSnapshot().find((session) => session.sessionId === sessionId);
+        if (live?.kind === "pet")
+            return;
+        ensurePetSession(sessionId, observedAt);
+        const version = nextPetProjectionVersion();
+        petSessionIndex.applyStreamEvent({
+            sessionId,
+            event,
+            generation: petWorkerGeneration(),
+            version,
+            observedAt,
+        });
+        const session = currentPetSessionProjection(sessionId, observedAt);
+        if (!session)
+            return;
+        sendPetProjectionDelta({
+            workerGeneration: petWorkerGeneration(),
+            version,
+            observedAt,
+            kind: "session-upsert",
+            session,
+        });
+    };
+    const emitPetSessionUpsert = (sessionId) => {
+        const observedAt = Date.now();
+        const session = currentPetSessionProjection(sessionId, observedAt);
+        if (!session)
+            return;
+        sendPetProjectionDelta({
+            workerGeneration: petWorkerGeneration(),
+            version: nextPetProjectionVersion(),
+            observedAt,
+            kind: "session-upsert",
+            session,
+        });
+    };
+    const emitPetSessionRemove = (sessionId) => {
+        const observedAt = Date.now();
+        sendPetProjectionDelta({
+            workerGeneration: petWorkerGeneration(),
+            version: nextPetProjectionVersion(),
+            observedAt,
+            kind: "session-remove",
+            sessionId,
+        });
+    };
+    const emitPetPendingUpsert = (pending) => {
+        const observedAt = Date.now();
+        sendPetProjectionDelta({
+            workerGeneration: petWorkerGeneration(),
+            version: nextPetProjectionVersion(),
+            observedAt,
+            kind: "pending-upsert",
+            pending,
+        });
+    };
+    const transitionPendingDecision = (metadata, status) => {
+        const observedAt = Date.now();
+        if (!pendingDecisionIndex.transition({
+            sessionId: metadata.sessionId,
+            requestId: metadata.requestId,
+            routeGeneration: metadata.routeGeneration,
+            status,
+            terminalAt: observedAt,
+        })) {
+            return;
+        }
+        sendPetProjectionDelta({
+            workerGeneration: petWorkerGeneration(),
+            version: nextPetProjectionVersion(),
+            observedAt,
+            kind: "pending-remove",
+            sessionId: metadata.sessionId,
+            requestId: metadata.requestId,
+            status,
+        });
+        emitPetSessionUpsert(metadata.sessionId);
+    };
+    const emitPetWorkerDisconnected = () => {
+        if (petProjectionDisconnected)
+            return;
+        petProjectionDisconnected = true;
+        const observedAt = Date.now();
+        const version = nextPetProjectionVersion();
+        petSessionIndex.applyWorkerLifecycle({
+            state: "disconnected",
+            generation: petWorkerGeneration(),
+            version,
+            observedAt,
+        });
+        sendPetProjectionDelta({
+            workerGeneration: petWorkerGeneration(),
+            version,
+            observedAt,
+            kind: "worker-state",
+            state: "disconnected",
+        });
+    };
+    // Compat channel: the wire method name stays agent/getPetProjectionSnapshot;
+    // the server routes it through this registration instead of pet-specific code.
+    host.registerQuery(GET_PET_PROJECTION_SNAPSHOT_METHOD, () => buildPetProjectionSnapshot());
+    return {
+        onSessionAttached: (sessionId, lastActivityAt) => {
+            ensurePetSession(sessionId, lastActivityAt);
+        },
+        onSessionStream: (sessionId, event) => {
+            recordPetStreamEvent(sessionId, event);
+        },
+        onRunBoundary: (sessionId) => {
+            emitPetSessionUpsert(sessionId);
+        },
+        onApprovalCreated: (metadata) => {
+            if (host.getSessionKind(metadata.sessionId) === "pet") {
+                metadata = { ...metadata, surfaceable: false };
+            }
+            if (pendingDecisionIndex.created(metadata)) {
+                const pending = pendingDecisionIndex.get(metadata.sessionId, metadata.requestId);
+                if (pending) {
+                    emitPetPendingUpsert(pending);
+                    emitPetSessionUpsert(metadata.sessionId);
+                }
+            }
+            return metadata;
+        },
+        onApprovalTransition: (metadata, status) => {
+            if (status === "pending")
+                return;
+            transitionPendingDecision(metadata, status);
+        },
+        onSessionClosed: (sessionId) => {
+            const observedAt = Date.now();
+            petCatalog.delete(sessionId);
+            petSessionIndex.replaceCatalog({
+                owner: LOCAL_PET_OWNER,
+                sessions: [...petCatalog.values()],
+                observedAt,
+            });
+            emitPetSessionRemove(sessionId);
+        },
+        onServerClose: () => {
+            petProjectionClosing = true;
+            emitPetWorkerDisconnected();
+        },
+        snapshotPendingDecisions: () => pendingDecisionIndex.snapshot(),
+    };
+}

package/dist/protocol.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Wire shapes for the Pet projection RPC surface. Deltas are pushed by the
+ * worker-side projection extension over the legacy notification method name
+ * `agent/petProjectionDelta`; the snapshot answers
+ * `agent/getPetProjectionSnapshot`. (Method names stay stable for the desktop
+ * bridge, which intercepts them by name.)
+ */
+import type { PendingDecisionProjection, PetProjectionSnapshot, PetSessionProjection, PetWorkerState } from "./types.js";
+export type PetProjectionDelta = {
+    workerGeneration: number;
+    version: number;
+    observedAt: number;
+    kind: "session-upsert";
+    session: PetSessionProjection;
+} | {
+    workerGeneration: number;
+    version: number;
+    observedAt: number;
+    kind: "session-remove";
+    sessionId: string;
+} | {
+    workerGeneration: number;
+    version: number;
+    observedAt: number;
+    kind: "pending-upsert";
+    pending: PendingDecisionProjection;
+} | {
+    workerGeneration: number;
+    version: number;
+    observedAt: number;
+    kind: "pending-remove";
+    sessionId: string;
+    requestId: string;
+    status: Exclude<PendingDecisionProjection["status"], "pending">;
+} | {
+    workerGeneration: number;
+    version: number;
+    observedAt: number;
+    kind: "worker-state";
+    state: PetWorkerState;
+};
+export type PetProjectionSnapshotResult = PetProjectionSnapshot;
+/** Any Session → host report routed to Mimi without revealing her hidden Session id. */
+export interface PetReportToMimiEvent {
+    reportId: string;
+    sessionId: string;
+    message: string;
+    attachmentPaths?: string[];
+    createdAt: number;
+}
+/**
+ * Wire method names, kept byte-identical to the pre-extraction core protocol
+ * so the desktop bridge (which intercepts by name) needs no changes. Core's
+ * Methods table retains the same strings as a compat surface.
+ */
+export declare const PET_PROJECTION_DELTA_METHOD = "agent/petProjectionDelta";
+export declare const GET_PET_PROJECTION_SNAPSHOT_METHOD = "agent/getPetProjectionSnapshot";
+export declare const PET_REPORT_TO_MIMI_METHOD = "agent/petReportToMimi";

package/dist/protocol.js

@@ -0,0 +1,15 @@
+/**
+ * Wire shapes for the Pet projection RPC surface. Deltas are pushed by the
+ * worker-side projection extension over the legacy notification method name
+ * `agent/petProjectionDelta`; the snapshot answers
+ * `agent/getPetProjectionSnapshot`. (Method names stay stable for the desktop
+ * bridge, which intercepts them by name.)
+ */
+/**
+ * Wire method names, kept byte-identical to the pre-extraction core protocol
+ * so the desktop bridge (which intercepts by name) needs no changes. Core's
+ * Methods table retains the same strings as a compat surface.
+ */
+export const PET_PROJECTION_DELTA_METHOD = "agent/petProjectionDelta";
+export const GET_PET_PROJECTION_SNAPSHOT_METHOD = "agent/getPetProjectionSnapshot";
+export const PET_REPORT_TO_MIMI_METHOD = "agent/petReportToMimi";

package/dist/report-to-mimi.d.ts

@@ -0,0 +1,7 @@
+import type { ToolContext, ToolDefinition, ToolVisibilityContext } from "@cjhyy/code-shell-core/extension";
+import type { PetReportToMimiEvent } from "./protocol.js";
+export declare const REPORT_TO_MIMI_TOOL_NAME = "ReportToMimi";
+export declare const reportToMimiToolDef: ToolDefinition;
+export type PetReportToMimiSink = (event: PetReportToMimiEvent) => void;
+export declare function reportToMimiAvailability(ctx: ToolVisibilityContext): boolean;
+export declare function reportToMimiTool(args: Record<string, unknown>, ctx?: ToolContext, report?: PetReportToMimiSink): Promise<string>;

package/dist/report-to-mimi.js

@@ -0,0 +1,87 @@
+import { createHash } from "node:crypto";
+import { isAbsolute } from "node:path";
+import { hasOnlyDeclaredToolArguments } from "./tool-arguments.js";
+export const REPORT_TO_MIMI_TOOL_NAME = "ReportToMimi";
+export const reportToMimiToolDef = {
+    name: REPORT_TO_MIMI_TOOL_NAME,
+    description: "Report a result, status update, artifact, or question from the current Session to Mimi. " +
+        "This works from any Session; Mimi decides how to present or act on the report. " +
+        "Do not search for Mimi's hidden Session id and do not provide a channel or recipient.",
+    inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            message: {
+                type: "string",
+                minLength: 1,
+                maxLength: 8_000,
+                description: "Complete concise report for Mimi, including outcome, evidence, and any user decision needed.",
+            },
+            attachment_paths: {
+                type: "array",
+                minItems: 1,
+                maxItems: 4,
+                uniqueItems: true,
+                items: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 4_096,
+                },
+                description: "Optional absolute local artifact paths for Mimi. The host independently decides whether any route may send them.",
+            },
+        },
+        required: ["message"],
+    },
+};
+export function reportToMimiAvailability(ctx) {
+    return isReportableSessionId(ctx.sessionId);
+}
+export async function reportToMimiTool(args, ctx, report) {
+    if (!isReportableSessionId(ctx?.sessionId)) {
+        return "Error: ReportToMimi requires a valid current Session.";
+    }
+    if (!report)
+        return "Error: the Mimi host reporting channel is unavailable.";
+    if (!hasOnlyDeclaredToolArguments(args, ["message", "attachment_paths"])) {
+        return "Error: ReportToMimi accepts only message and attachment_paths.";
+    }
+    const message = typeof args.message === "string" ? args.message.trim() : "";
+    if (!message || message.length > 8_000) {
+        return "Error: ReportToMimi message must be 1 to 8000 characters.";
+    }
+    const attachmentPaths = parseAttachmentPaths(args.attachment_paths);
+    if (attachmentPaths === null) {
+        return "Error: attachment_paths must contain 1 to 4 unique absolute paths.";
+    }
+    const reportId = createHash("sha256")
+        .update([ctx.sessionId, ctx.originClientMessageId ?? "", message, ...(attachmentPaths ?? [])].join("\0"))
+        .digest("hex")
+        .slice(0, 32);
+    report({
+        reportId,
+        sessionId: ctx.sessionId,
+        message,
+        ...(attachmentPaths ? { attachmentPaths } : {}),
+        createdAt: Date.now(),
+    });
+    return "Report accepted by Mimi's host. Delivery is asynchronous; do not search for Mimi's Session id or claim that an IM message was delivered.";
+}
+function parseAttachmentPaths(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) ||
+        value.length < 1 ||
+        value.length > 4 ||
+        !value.every((path) => typeof path === "string" && path.length > 0 && path.length <= 4_096 && isAbsolute(path)) ||
+        new Set(value).size !== value.length) {
+        return null;
+    }
+    return [...value];
+}
+function isReportableSessionId(value) {
+    return (typeof value === "string" &&
+        value.length >= 1 &&
+        value.length <= 256 &&
+        value === value.trim() &&
+        !/[\u0000-\u001f\u007f]/u.test(value));
+}

package/dist/run-params.d.ts

@@ -0,0 +1,34 @@
+import { type PetReusableSessionOption, type PetWorkspaceOption } from "./delegation.js";
+import { type PetGatewayReplyCapability, type PetHostActionKind } from "./host-actions.js";
+import { type PetGatewayCatalog } from "./gateway.js";
+import type { PetFollowUpItem } from "./follow-ups.js";
+import type { PetOutboundTargetOption } from "./outbound-message.js";
+export interface PetRunOptions {
+    workspaces: readonly PetWorkspaceOption[];
+    reusableSessions: readonly PetReusableSessionOption[];
+    /** Host-action kinds the host declared it can execute this turn. */
+    hostActionKinds: readonly PetHostActionKind[];
+    /** Exact outbound route contract backing GatewayReply for this turn. */
+    gatewayReply?: PetGatewayReplyCapability;
+    /** Adapter-owned first-level discovery catalog backing the Gateway tool. */
+    gateway?: PetGatewayCatalog;
+    /** Host-provided sessions directory backing the Sessions tool. */
+    sessionsRootDir?: string;
+    /** The actionable rows shown in the desktop Needs follow-up section. */
+    followUps: readonly PetFollowUpItem[];
+    /** Host-authorized proactive owner destinations. */
+    outboundTargets: readonly PetOutboundTargetOption[];
+}
+/**
+ * Build an immutable, bounded per-turn snapshot for the Pet behavior profile.
+ *
+ * AgentServer validates the same shapes before dispatch. This second line of
+ * defense matters for in-process Engine hosts, which can invoke the behavior
+ * profile directly without crossing the protocol validator.
+ */
+export declare function petRunOptionsFrom(profileParams: Readonly<Record<string, unknown>>): PetRunOptions;
+/**
+ * Pet-specific agent/run params validation. Canonical profileParams keys win
+ * over legacy pet aliases, matching Engine's merge precedence.
+ */
+export declare function validatePetRunParams(params: Record<string, unknown>): string | null;