@chatcode/chatcode-cli 3.0.4-rc.1 → 3.0.4-rc.2

package/runtime/node_modules/@deepseek-ai/dsh-workspace/lib/types/index.js

@@ -4,9 +4,62 @@
  * domain data form.
  * @module @deepseek-ai/dsh-workspace
  */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { randomUUID } from 'node:crypto';
 import { mkdir, stat } from 'node:fs/promises';
 import { Service } from '@deepseek-ai/cordis';
+import { SessionAlreadyOwnedError } from '@deepseek-ai/dsh-session-persistence';
 import { WorkspaceEntity } from "./entity.js";
 export { WorkspaceMoveInvalidError } from "./entity.js";
 import { defaultWorkspaceTitle, fullyQualifiedWorkspacePath, realpathNormalize } from "./paths.js";
@@ -69,6 +122,21 @@ export class WorkspaceArchivedSessionPinError extends Error {
         this.name = 'WorkspaceArchivedSessionPinError';
     }
 }
+/** Permanent deletion requires an archived root and no active Session ownership. */
+export class WorkspaceSessionDeletionError extends Error {
+    sessionId;
+    reason;
+    /**
+     * @param sessionId - identity whose lifecycle prevents the requested operation.
+     * @param reason - stable refusal discriminant shared by the Web and TUI.
+     */
+    constructor(sessionId, reason) {
+        super(`cannot delete session '${sessionId}': ${reason}`);
+        this.sessionId = sessionId;
+        this.reason = reason;
+        this.name = 'WorkspaceSessionDeletionError';
+    }
+}
 /** A workspace reorder named a source or anchor absent from the durable registry order. */
 export class WorkspaceOrderInvalidError extends Error {
     workspaceId;
@@ -134,6 +202,7 @@ export class WorkspaceRegistry extends Service {
             await domain.refresh();
             this.state = domain.global.get();
             await this.recoverPendingMutation();
+            await this.recoverSessionDeletion();
             this.validateStoredState(this.requireState());
             if (!this.requireState().initialized) {
                 const headers = await this.listStoredHeaders();
@@ -296,6 +365,144 @@ export class WorkspaceRegistry extends Service {
     get archivedSessionIds() {
         return this.requireState().archivedSessionIds;
     }
+    /** Permanently deleted identities retained for cross-process invalidation and stale-operation refusal. */
+    get deletedSessionIds() {
+        return this.requireState().deletedSessionIds ?? [];
+    }
+    /**
+     * Permanently delete an archived, inactive root and its owned subagent descendants.
+     * Independent forks are preserved. Reserve every writer before recording a recovery
+     * marker; a failure after that marker is retried on refresh or restart.
+     * @param sessionId - archived root identity; repeated deletion is idempotent.
+     * @param expectedIds - identities confirmed by the user; a changed scope refuses deletion.
+     * @returns deleted root and descendant identities after durable cleanup.
+     */
+    deleteSession(sessionId, expectedIds) {
+        return this.enqueueOperation(async () => {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.deletedSessionIds.includes(sessionId))
+                    return [sessionId];
+                if (!this.archivedSessionIds.includes(sessionId))
+                    throw new WorkspaceSessionDeletionError(sessionId, 'not-archived');
+                const ids = new Set(await this.collectSessionDeletionScope(sessionId));
+                if (expectedIds !== undefined && (expectedIds.length !== ids.size
+                    || new Set(expectedIds).size !== ids.size || expectedIds.some(id => !ids.has(id)))) {
+                    throw new WorkspaceSessionDeletionError(sessionId, 'scope-changed');
+                }
+                for (const id of ids) {
+                    const activity = await this.ctx.waterfall('workspace/session-activity', { sessionId: id }, () => Promise.resolve([]));
+                    if (activity.length > 0)
+                        throw new WorkspaceActiveSessionError(id, activity);
+                }
+                const targets = [...ids];
+                await this.ctx.parallel('session/delete-release', { sessionIds: targets });
+                for (const id of ids) {
+                    if (this.ctx.get('sessions')?.get(id) !== undefined)
+                        throw new WorkspaceSessionDeletionError(id, 'in-use');
+                }
+                const reservation = __addDisposableResource(env_1, await this.ctx.sessionPersistence.prepareDeletion(targets).catch((error) => {
+                    if (error instanceof SessionAlreadyOwnedError)
+                        throw new WorkspaceSessionDeletionError(sessionId, 'in-use');
+                    throw error;
+                }), true);
+                await this.setState({ ...this.requireState(), pendingSessionDeletion: targets });
+                await reservation.commit();
+                await this.finishSessionDeletion(targets);
+                return targets;
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
+            }
+        });
+    }
+    /**
+     * Preview the root and owned descendants without opening their histories.
+     * @param sessionId - archived root to preview.
+     * @returns identities to show in the deletion confirmation.
+     */
+    sessionDeletionScope(sessionId) {
+        return this.enqueueOperation(async () => {
+            if (!this.archivedSessionIds.includes(sessionId))
+                throw new WorkspaceSessionDeletionError(sessionId, 'not-archived');
+            return this.collectSessionDeletionScope(sessionId);
+        });
+    }
+    async collectSessionDeletionScope(sessionId) {
+        const headers = await this.listStoredHeaders();
+        const ids = new Set([sessionId]);
+        for (let changed = true; changed;) {
+            changed = false;
+            for (const header of headers) {
+                if (header.origin === 'subagent' && header.parentSession !== undefined
+                    && ids.has(header.parentSession) && !ids.has(header.id)) {
+                    ids.add(header.id);
+                    changed = true;
+                }
+            }
+        }
+        return [...ids];
+    }
+    async recoverSessionDeletion() {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const ids = this.requireState().pendingSessionDeletion;
+            if (ids === undefined)
+                return;
+            const reservation = __addDisposableResource(env_2, await this.ctx.sessionPersistence.prepareDeletion(ids), true);
+            await reservation.commit();
+            await this.finishSessionDeletion(ids);
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
+    }
+    notifyDeleted(ids) {
+        try {
+            this.ctx.emit('session/deleted', ids);
+        }
+        catch (error) {
+            this.ctx.logger.warn(`workspace: deletion listener failed: ${String(error)}`);
+        }
+    }
+    async finishSessionDeletion(ids) {
+        await this.ctx.parallel('session/deleting', { sessionIds: ids });
+        const removed = new Set(ids);
+        for (const [id, record] of this.requireTable().entries()) {
+            if (record.sessionIds.some(member => removed.has(member))) {
+                await this.requireTable().update(id, current => ({
+                    ...current, sessionIds: current.sessionIds.filter(member => !removed.has(member)), updatedAt: new Date().toISOString(),
+                }));
+            }
+        }
+        const state = this.requireState();
+        await this.setState({
+            ...state,
+            archivedSessionIds: state.archivedSessionIds.filter(id => !removed.has(id)),
+            pinnedSessionIds: state.pinnedSessionIds.filter(id => !removed.has(id)),
+            deletedSessionIds: [...new Set([...(state.deletedSessionIds ?? []), ...ids])],
+            pendingSessionDeletion: undefined,
+        });
+        for (const id of ids) {
+            this.headers.delete(id);
+            this.sessionPaths.delete(id);
+            this.invalidSessionPaths.delete(id);
+        }
+        this.rebuildEntities();
+        this.notifyDeleted(ids);
+    }
     /**
      * Archive one session durably. The session must exist (live or in session
      * persistence); its workspace accounting — or lack of one — is irrelevant.
@@ -349,6 +556,8 @@ export class WorkspaceRegistry extends Service {
      */
     unarchiveSession(sessionId) {
         return this.enqueueOperation(async () => {
+            if (this.deletedSessionIds.includes(sessionId))
+                throw new WorkspaceSessionDeletionError(sessionId, 'deleted');
             // The chain slot serializes against every other registry write, so this
             // check-then-write pair cannot interleave with a concurrent archive.
             const state = this.requireState();
@@ -422,6 +631,8 @@ export class WorkspaceRegistry extends Service {
      * masquerade as an unknown session.
      */
     async sessionKnown(id) {
+        if (this.deletedSessionIds.includes(id))
+            return false;
         if (this.ctx.get('sessions')?.get(id) !== undefined)
             return true;
         if (this.headers.has(id))
@@ -766,13 +977,14 @@ export class WorkspaceRegistry extends Service {
     /** Every stored session's header, projected from the persistence snapshot listing. */
     async listStoredHeaders() {
         const snapshots = await this.ctx.sessionPersistence.list();
-        return snapshots.map(snapshot => snapshot.header);
+        const deleted = new Set(this.deletedSessionIds);
+        return snapshots.map(snapshot => snapshot.header).filter(header => !deleted.has(header.id));
     }
     async indexLiveSessions() {
         const sessions = this.ctx.get('sessions');
         if (sessions === undefined)
             return;
-        await this.indexHeaders(sessions.list().map(session => session.header));
+        await this.indexHeaders(sessions.list().filter(session => !this.deletedSessionIds.includes(session.id)).map(session => session.header));
     }
     reportFilteredCandidates() {
         for (const entity of this.entities.values()) {
@@ -829,6 +1041,7 @@ export class WorkspaceRegistry extends Service {
                 throw new Error('workspace registry is not started yet');
             return await domain.exclusive(async () => {
                 const before = JSON.stringify([...this.entities.values()].map(entity => [entity.id, entity.sessionIds]));
+                const previousDeleted = new Set(this.deletedSessionIds);
                 await domain.refresh();
                 const changed = this.snapshotIdentity() !== this.refreshedState;
                 this.state = domain.global.get();
@@ -839,6 +1052,10 @@ export class WorkspaceRegistry extends Service {
                     this.rebuildEntities();
                 }
                 await this.recoverPendingMutation();
+                await this.recoverSessionDeletion();
+                const newlyDeleted = this.deletedSessionIds.filter(id => !previousDeleted.has(id));
+                if (newlyDeleted.length > 0)
+                    this.notifyDeleted(newlyDeleted);
                 this.validateStoredState(this.requireState());
                 const after = JSON.stringify([...this.entities.values()].map(entity => [entity.id, entity.sessionIds]));
                 if (changed || before !== after) {

package/runtime/node_modules/@deepseek-ai/dsh-workspace/lib/types/spec.d.ts

@@ -46,6 +46,8 @@ export declare const workspaceDomainState: z.ZodObject<{
         operation: z.ZodLiteral<"delete">;
         workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<WorkspaceId, string>>;
     }, z.core.$strip>], "operation">>;
+    deletedSessionIds: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
+    pendingSessionDeletion: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
 }, z.core.$strip>;
 /** Durable registry state inferred from {@link workspaceDomainState}. */
 export type WorkspaceDomainState = z.infer<typeof workspaceDomainState>;
@@ -72,6 +74,8 @@ export declare const workspaceDomainSpec: {
                 operation: z.ZodLiteral<"delete">;
                 workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<WorkspaceId, string>>;
             }, z.core.$strip>], "operation">>;
+            deletedSessionIds: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
+            pendingSessionDeletion: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<SessionId, string>>>>;
         }, z.core.$strip>;
         initial: {
             initialized: boolean;

package/runtime/node_modules/@deepseek-ai/dsh-workspace/lib/types/spec.js

@@ -51,6 +51,10 @@ export const workspaceDomainState = z.object({
     archivedSessionIds: z.array(sessionId).default([]),
     pinnedSessionIds: z.array(sessionId).default([]),
     pendingMutation: workspacePendingMutation.optional(),
+    /** Payload deletion committed identities; old processes must never restore these Sessions. */
+    deletedSessionIds: z.array(sessionId).optional(),
+    /** Complete deletion scope retained until payloads and secondary owners finish cleanup. */
+    pendingSessionDeletion: z.array(sessionId).optional(),
 });
 /**
  * The workspace domain spec: one `workspaces` table keyed by