shennian 0.3.85 → 0.3.86

package/dist/src/session/native-cleanup-outbox.js

@@ -1,2 +1,287 @@
-import l from"node:crypto";import r from"node:fs";import p from"node:path";import{resolvePersonalSyncV1Path as m}from"../personal-sync/paths.js";import{getDaemonInstallationId as h}from"../personal-sync/identity.js";import{NativeSourceDeletionStore as y}from"../native-fusion/native-source-deletions.js";import{NativeSessionLifecycleRegistry as f}from"./native-session-lifecycle.js";const d=1,I=8,S=6e4,b=360*60*1e3,u=new Set(["succeeded_archived","succeeded_deleted","succeeded_already_absent","skipped_unsupported","skipped_invalid_identity","failed_permanent"]);class x{options;lifecycle;timer=null;drainPromise=null;constructor(t={}){this.options=t,this.lifecycle=t.lifecycle??new f}start(){this.timer||(this.drain(),this.timer=setInterval(()=>{this.drain()},this.options.drainIntervalMs??S),this.timer.unref?.())}stop(){this.timer&&clearInterval(this.timer),this.timer=null}enqueue(t){if((t.nativeCleanupPolicy??"none")!=="auto")return[];const s=this.read(!0),i=[];for(const e of t.sources){const o=this.jobId(t,e.agentType,e.sourceSessionKey),n=s.jobs[o];if(n){i.push(n);continue}const c={schemaVersion:d,daemonInstallationId:this.installationId(),jobId:o,sessionId:t.sessionId,deletionRevision:t.deletionRevision,agentType:e.agentType,sourceSessionKey:e.sourceSessionKey,...t.workDir?{workDir:t.workDir}:{},requestedAt:t.deletedAt,state:"pending",attempts:0};s.jobs[o]=c,i.push(c)}return i.some(e=>e.state==="pending")&&this.write(s),i}kick(){this.drain()}async drain(){return this.drainPromise?await this.drainPromise:(this.drainPromise=this.drainOnce().finally(()=>{this.drainPromise=null}),await this.drainPromise)}listJobs(){return Object.values(this.read(!0).jobs).sort((t,s)=>t.deletionRevision-s.deletionRevision||t.jobId.localeCompare(s.jobId))}async drainOnce(){for(;;){const t=this.read(!0),s=this.now(),i=Object.values(t.jobs).filter(o=>o.state==="pending"||o.state==="retry_wait"&&(!o.nextAttemptAt||Date.parse(o.nextAttemptAt)<=s.getTime())).sort((o,n)=>o.deletionRevision-n.deletionRevision||o.jobId.localeCompare(n.jobId))[0];if(!i)return;i.state="running",i.attempts+=1,delete i.nextAttemptAt,this.write(t);let e;if(!this.sourceGuard(i))e={outcome:"invalid_identity"};else try{e=await this.lifecycle.execute(i.agentType,i.sourceSessionKey,{workDir:i.workDir})}catch{e={outcome:"transient",errorCode:"lifecycle_unexpected_failure"}}this.applyResult(i.jobId,e)}}applyResult(t,s){const i=this.read(!1),e=i.jobs[t];if(!e||u.has(e.state))return;const o=this.now().toISOString();switch(s.outcome){case"archived":e.state="succeeded_archived";break;case"deleted":e.state="succeeded_deleted";break;case"already_absent":e.state="succeeded_already_absent";break;case"unsupported":e.state="skipped_unsupported";break;case"invalid_identity":e.state="skipped_invalid_identity";break;case"permanent":e.state="failed_permanent",e.lastErrorCode=s.errorCode;break;case"transient":{if(e.lastErrorCode=s.errorCode,e.attempts>=(this.options.maxAttempts??I)){e.state="failed_permanent";break}e.state="retry_wait";const n=Math.min((this.options.retryBaseMs??5e3)*2**Math.max(0,e.attempts-1),b);e.nextAttemptAt=new Date(this.now().getTime()+n).toISOString(),delete e.completedAt,this.write(i),this.log(e,s.errorCode);return}}e.completedAt=o,delete e.nextAttemptAt,this.write(i),this.log(e,e.lastErrorCode??s.outcome)}sourceGuard(t){if(this.options.sourceGuard)return this.options.sourceGuard(t);const s=new y({rootDir:this.rootDir(),daemonInstallationId:this.installationId()}).find(t.agentType,t.sourceSessionKey);return!!(s&&s.sessionId===t.sessionId&&s.deletionRevision===t.deletionRevision)}log(t,s){this.options.logger?.("[native-cleanup] job state changed",{job:t.jobId.slice(0,12),provider:t.agentType,state:t.state,result:s,attempts:t.attempts})}read(t){const s=this.filePath();if(!r.existsSync(s))return this.emptyFile();const i=JSON.parse(r.readFileSync(s,"utf8"));if(i.schemaVersion!==d||i.daemonInstallationId!==this.installationId()||!i.jobs||typeof i.jobs!="object"||Array.isArray(i.jobs))throw new Error("invalid native cleanup outbox");let e=!1;for(const[o,n]of Object.entries(i.jobs)){if(o!==n.jobId||n.schemaVersion!==d||n.daemonInstallationId!==this.installationId()||!n.sessionId||!n.agentType||!n.sourceSessionKey||!Number.isSafeInteger(n.deletionRevision)||n.deletionRevision<1||!Number.isSafeInteger(n.attempts)||n.attempts<0||!u.has(n.state)&&n.state!=="pending"&&n.state!=="running"&&n.state!=="retry_wait")throw new Error("invalid native cleanup job");t&&n.state==="running"&&(n.state="pending",e=!0)}return e&&this.write(i),i}write(t){v(this.filePath(),t)}emptyFile(){return{schemaVersion:d,daemonInstallationId:this.installationId(),jobs:{}}}jobId(t,s,i){return l.createHash("sha256").update(`${this.installationId()}\0${t.deletionRevision}\0${s}\0${i}`).digest("hex")}installationId(){return this.options.daemonInstallationId??h()}rootDir(){return this.options.rootDir??m()}filePath(){return p.join(this.rootDir(),"native-session-cleanup-outbox.json")}now(){return this.options.now?.()??new Date}}function v(a,t){const s=p.dirname(a);r.mkdirSync(s,{recursive:!0,mode:448});const i=`${a}.tmp-${process.pid}-${l.randomBytes(6).toString("hex")}`;let e;try{if(e=r.openSync(i,"wx",384),r.writeFileSync(e,`${JSON.stringify(t,null,2)}
-`,"utf8"),r.fsyncSync(e),r.closeSync(e),e=void 0,r.renameSync(i,a),process.platform!=="win32"){const o=r.openSync(s,"r");try{r.fsyncSync(o)}finally{r.closeSync(o)}}}finally{e!==void 0&&r.closeSync(e);try{r.unlinkSync(i)}catch{}}}export{x as NativeSessionCleanupOutbox};
+// @arch docs/features/native-session-deletion-sync.md#七本机原生清理-outbox
+// @test src/__tests__/native-cleanup-outbox.test.ts
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { resolvePersonalSyncV1Path } from '../personal-sync/paths.js';
+import { getDaemonInstallationId } from '../personal-sync/identity.js';
+import { NativeSourceDeletionStore } from '../native-fusion/native-source-deletions.js';
+import { NativeSessionLifecycleRegistry, } from './native-session-lifecycle.js';
+const SCHEMA_VERSION = 1;
+const DEFAULT_MAX_ATTEMPTS = 8;
+const DEFAULT_DRAIN_INTERVAL_MS = 60_000;
+const MAX_BACKOFF_MS = 6 * 60 * 60 * 1_000;
+const TERMINAL_STATES = new Set([
+    'succeeded_archived',
+    'succeeded_deleted',
+    'succeeded_already_absent',
+    'skipped_unsupported',
+    'skipped_invalid_identity',
+    'failed_permanent',
+]);
+export class NativeSessionCleanupOutbox {
+    options;
+    lifecycle;
+    timer = null;
+    drainPromise = null;
+    constructor(options = {}) {
+        this.options = options;
+        this.lifecycle = options.lifecycle ?? new NativeSessionLifecycleRegistry();
+    }
+    start() {
+        if (this.timer)
+            return;
+        void this.drain();
+        this.timer = setInterval(() => void this.drain(), this.options.drainIntervalMs ?? DEFAULT_DRAIN_INTERVAL_MS);
+        this.timer.unref?.();
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+    }
+    enqueue(deletion) {
+        if ((deletion.nativeCleanupPolicy ?? 'none') !== 'auto')
+            return [];
+        const file = this.read(true);
+        const created = [];
+        for (const source of deletion.sources) {
+            const jobId = this.jobId(deletion, source.agentType, source.sourceSessionKey);
+            const existing = file.jobs[jobId];
+            if (existing) {
+                created.push(existing);
+                continue;
+            }
+            const job = {
+                schemaVersion: SCHEMA_VERSION,
+                daemonInstallationId: this.installationId(),
+                jobId,
+                sessionId: deletion.sessionId,
+                deletionRevision: deletion.deletionRevision,
+                agentType: source.agentType,
+                sourceSessionKey: source.sourceSessionKey,
+                ...(deletion.workDir ? { workDir: deletion.workDir } : {}),
+                requestedAt: deletion.deletedAt,
+                state: 'pending',
+                attempts: 0,
+            };
+            file.jobs[jobId] = job;
+            created.push(job);
+        }
+        if (created.some((job) => job.state === 'pending'))
+            this.write(file);
+        return created;
+    }
+    kick() {
+        void this.drain();
+    }
+    async drain() {
+        if (this.drainPromise)
+            return await this.drainPromise;
+        this.drainPromise = this.drainOnce().finally(() => {
+            this.drainPromise = null;
+        });
+        return await this.drainPromise;
+    }
+    listJobs() {
+        return Object.values(this.read(true).jobs).sort((left, right) => left.deletionRevision - right.deletionRevision || left.jobId.localeCompare(right.jobId));
+    }
+    async drainOnce() {
+        // One global worker is an intentional upper bound. It also guarantees that
+        // every Provider is serialized without a second lock hierarchy.
+        while (true) {
+            const file = this.read(true);
+            const now = this.now();
+            const job = Object.values(file.jobs)
+                .filter((candidate) => candidate.state === 'pending' ||
+                (candidate.state === 'retry_wait' &&
+                    (!candidate.nextAttemptAt || Date.parse(candidate.nextAttemptAt) <= now.getTime())))
+                .sort((left, right) => left.deletionRevision - right.deletionRevision || left.jobId.localeCompare(right.jobId))[0];
+            if (!job)
+                return;
+            job.state = 'running';
+            job.attempts += 1;
+            delete job.nextAttemptAt;
+            this.write(file);
+            let result;
+            if (!this.sourceGuard(job)) {
+                result = { outcome: 'invalid_identity' };
+            }
+            else {
+                try {
+                    result = await this.lifecycle.execute(job.agentType, job.sourceSessionKey, {
+                        workDir: job.workDir,
+                    });
+                }
+                catch {
+                    result = { outcome: 'transient', errorCode: 'lifecycle_unexpected_failure' };
+                }
+            }
+            this.applyResult(job.jobId, result);
+        }
+    }
+    applyResult(jobId, result) {
+        const file = this.read(false);
+        const job = file.jobs[jobId];
+        if (!job || TERMINAL_STATES.has(job.state))
+            return;
+        const completedAt = this.now().toISOString();
+        switch (result.outcome) {
+            case 'archived':
+                job.state = 'succeeded_archived';
+                break;
+            case 'deleted':
+                job.state = 'succeeded_deleted';
+                break;
+            case 'already_absent':
+                job.state = 'succeeded_already_absent';
+                break;
+            case 'unsupported':
+                job.state = 'skipped_unsupported';
+                break;
+            case 'invalid_identity':
+                job.state = 'skipped_invalid_identity';
+                break;
+            case 'permanent':
+                job.state = 'failed_permanent';
+                job.lastErrorCode = result.errorCode;
+                break;
+            case 'transient': {
+                job.lastErrorCode = result.errorCode;
+                if (job.attempts >= (this.options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS)) {
+                    job.state = 'failed_permanent';
+                    break;
+                }
+                job.state = 'retry_wait';
+                const delay = Math.min((this.options.retryBaseMs ?? 5_000) * 2 ** Math.max(0, job.attempts - 1), MAX_BACKOFF_MS);
+                job.nextAttemptAt = new Date(this.now().getTime() + delay).toISOString();
+                delete job.completedAt;
+                this.write(file);
+                this.log(job, result.errorCode);
+                return;
+            }
+        }
+        job.completedAt = completedAt;
+        delete job.nextAttemptAt;
+        this.write(file);
+        this.log(job, job.lastErrorCode ?? result.outcome);
+    }
+    sourceGuard(job) {
+        if (this.options.sourceGuard)
+            return this.options.sourceGuard(job);
+        const deletion = new NativeSourceDeletionStore({
+            rootDir: this.rootDir(),
+            daemonInstallationId: this.installationId(),
+        }).find(job.agentType, job.sourceSessionKey);
+        return Boolean(deletion &&
+            deletion.sessionId === job.sessionId &&
+            deletion.deletionRevision === job.deletionRevision);
+    }
+    log(job, result) {
+        this.options.logger?.('[native-cleanup] job state changed', {
+            job: job.jobId.slice(0, 12),
+            provider: job.agentType,
+            state: job.state,
+            result,
+            attempts: job.attempts,
+        });
+    }
+    read(recoverRunning) {
+        const filePath = this.filePath();
+        if (!fs.existsSync(filePath))
+            return this.emptyFile();
+        const parsed = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (parsed.schemaVersion !== SCHEMA_VERSION ||
+            parsed.daemonInstallationId !== this.installationId() ||
+            !parsed.jobs ||
+            typeof parsed.jobs !== 'object' ||
+            Array.isArray(parsed.jobs)) {
+            throw new Error('invalid native cleanup outbox');
+        }
+        let recovered = false;
+        for (const [key, job] of Object.entries(parsed.jobs)) {
+            if (key !== job.jobId ||
+                job.schemaVersion !== SCHEMA_VERSION ||
+                job.daemonInstallationId !== this.installationId() ||
+                !job.sessionId ||
+                !job.agentType ||
+                !job.sourceSessionKey ||
+                !Number.isSafeInteger(job.deletionRevision) ||
+                job.deletionRevision < 1 ||
+                !Number.isSafeInteger(job.attempts) ||
+                job.attempts < 0 ||
+                (!TERMINAL_STATES.has(job.state) &&
+                    job.state !== 'pending' &&
+                    job.state !== 'running' &&
+                    job.state !== 'retry_wait')) {
+                throw new Error('invalid native cleanup job');
+            }
+            if (recoverRunning && job.state === 'running') {
+                job.state = 'pending';
+                recovered = true;
+            }
+        }
+        if (recovered)
+            this.write(parsed);
+        return parsed;
+    }
+    write(file) {
+        atomicWriteJson(this.filePath(), file);
+    }
+    emptyFile() {
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            daemonInstallationId: this.installationId(),
+            jobs: {},
+        };
+    }
+    jobId(deletion, agentType, sourceSessionKey) {
+        return crypto
+            .createHash('sha256')
+            .update(`${this.installationId()}\0${deletion.deletionRevision}\0${agentType}\0${sourceSessionKey}`)
+            .digest('hex');
+    }
+    installationId() {
+        return this.options.daemonInstallationId ?? getDaemonInstallationId();
+    }
+    rootDir() {
+        return this.options.rootDir ?? resolvePersonalSyncV1Path();
+    }
+    filePath() {
+        return path.join(this.rootDir(), 'native-session-cleanup-outbox.json');
+    }
+    now() {
+        return this.options.now?.() ?? new Date();
+    }
+}
+function atomicWriteJson(file, value) {
+    const directory = path.dirname(file);
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const temp = `${file}.tmp-${process.pid}-${crypto.randomBytes(6).toString('hex')}`;
+    let descriptor;
+    try {
+        descriptor = fs.openSync(temp, 'wx', 0o600);
+        fs.writeFileSync(descriptor, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        fs.fsyncSync(descriptor);
+        fs.closeSync(descriptor);
+        descriptor = undefined;
+        fs.renameSync(temp, file);
+        if (process.platform !== 'win32') {
+            const directoryDescriptor = fs.openSync(directory, 'r');
+            try {
+                fs.fsyncSync(directoryDescriptor);
+            }
+            finally {
+                fs.closeSync(directoryDescriptor);
+            }
+        }
+    }
+    finally {
+        if (descriptor !== undefined)
+            fs.closeSync(descriptor);
+        try {
+            fs.unlinkSync(temp);
+        }
+        catch { }
+    }
+}

package/dist/src/session/native-session-lifecycle.js

@@ -1,6 +1,327 @@
-import{createInterface as E}from"node:readline";import D from"node:fs";import{isAvailableBuiltinAgentType as g}from"@shennian/wire";import{buildAgentProcessEnv as w}from"../agent-env.js";import{resolveBuiltinCommand as b,spawnAgentCommand as y}from"../agents/command-spec.js";const C=64*1024,h=/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,k=/^ses_[A-Za-z0-9_-]{6,191}$/;function A(n,r){return n.length>=C?n:`${n}${String(r)}`.slice(0,C)}const x=async(n,r,i=1e4,e)=>{if(!g(n))return{code:null,stdout:"",stderr:"",timedOut:!1,spawnErrorCode:"command_unavailable"};const t=b(n);return t?await new Promise(c=>{let s="",l="",d=!1,m=!1;const p=y(t,r,{stdio:["ignore","pipe","pipe"],env:w({NO_COLOR:"1"}),...e?{cwd:e}:{}}),u=o=>{d||(d=!0,a&&clearTimeout(a),c({...o,stdout:s,stderr:l,timedOut:m}))};p.stdout?.on("data",o=>{s=A(s,o)}),p.stderr?.on("data",o=>{l=A(l,o)}),p.on("error",o=>{u({code:null,spawnErrorCode:o.code??"spawn_failed"})}),p.on("close",o=>u({code:o}));const a=setTimeout(()=>{m=!0,p.kill("SIGTERM"),setTimeout(()=>p.kill("SIGKILL"),1e3).unref?.()},i);a.unref?.()}):{code:null,stdout:"",stderr:"",timedOut:!1,spawnErrorCode:"command_unavailable"}};function $(n){return`${n.stdout}
-${n.stderr}`.toLowerCase()}function f(n,r){if(n.spawnErrorCode==="command_unavailable"||n.spawnErrorCode==="ENOENT")return{outcome:"unsupported"};if(n.timedOut)return{outcome:"transient",errorCode:"command_timeout"};const i=$(n);return/not found|does not exist|no session|unknown session|already (?:deleted|archived)/.test(i)?{outcome:"already_absent"}:/busy|locked|writer|in use|current active session|active turn|temporar|try again|timed out|timeout/.test(i)?{outcome:"transient",errorCode:"native_busy"}:/invalid.*(?:uuid|session|id)|malformed/.test(i)?{outcome:"invalid_identity"}:/permission denied|unauthenticated|authentication|forbidden/.test(i)?{outcome:"permanent",errorCode:"native_auth_required"}:n.code===0?{outcome:r}:{outcome:"transient",errorCode:"native_command_failed"}}async function _(n,r,i,e){const t=await n(r,i);return!t.timedOut&&t.code===0&&e.test(`${t.stdout}
-${t.stderr}`)}async function I(n,r){return await new Promise(i=>{let e=null,t=!1,c=1,s=null;const l=new Map,d=u=>{if(!t){t=!0,s&&clearTimeout(s);for(const a of l.values())a.reject(new Error("app_server_stopped"));l.clear(),e?.kill("SIGTERM"),i(u)}},m=(u,a)=>{if(!e?.stdin)return Promise.reject(new Error("app_server_unavailable"));const o=c++;return new Promise((v,O)=>{l.set(o,{resolve:v,reject:O}),e.stdin.write(`${JSON.stringify({id:o,method:u,params:a})}
-`)})};try{e=y(n,["app-server","--listen","stdio://"],{stdio:["pipe","pipe","ignore"],env:w({NO_COLOR:"1"})})}catch{d({outcome:"transient",errorCode:"app_server_start_failed"});return}E({input:e.stdout}).on("line",u=>{if(!u.trim())return;let a;try{a=JSON.parse(u)}catch{return}if(a.id==null)return;const o=l.get(a.id);if(o)if(l.delete(a.id),a.error){const v=new Error(a.error.message??"app_server_error");v.rpcCode=a.error.code,o.reject(v)}else o.resolve(a.result)}),e.on("error",()=>d({outcome:"transient",errorCode:"app_server_start_failed"})),e.on("close",()=>{t||d({outcome:"transient",errorCode:"app_server_stopped"})}),s=setTimeout(()=>d({outcome:"transient",errorCode:"app_server_timeout"}),12e3),s.unref?.(),(async()=>{try{await m("initialize",{clientInfo:{name:"shennian-native-cleanup",title:"Shennian",version:"1"},capabilities:{experimentalApi:!0}}),await m("thread/archive",{threadId:r}),d({outcome:"archived"})}catch(u){const a=u,o=a.message.toLowerCase();/not found|does not exist|already archived|no rollout/.test(o)?d({outcome:"already_absent"}):/busy|locked|writer|active turn|in use/.test(o)?d({outcome:"transient",errorCode:"native_busy"}):a.rpcCode===-32601||/method not found|unsupported/.test(o)?d({outcome:"unsupported"}):d({outcome:"transient",errorCode:"app_server_failed"})}})()})}class S{options;capabilities=new Map;constructor(r={}){this.options=r}async execute(r,i,e={}){const t=this.adapter(r),c=await this.probe(r,t);if(c.canArchive&&t.archive)return await t.archive(i);if(c.canDelete&&t.delete){if(r==="gemini"&&!e.workDir)return{outcome:"invalid_identity"};if((r==="gemini"||r==="opencode")&&e.workDir)try{if(!D.statSync(e.workDir).isDirectory())return{outcome:"permanent",errorCode:"workdir_unavailable"}}catch{return{outcome:"permanent",errorCode:"workdir_unavailable"}}return await this.deleteWithContext(t,i,e)}return{outcome:"unsupported"}}async deleteWithContext(r,i,e){return r.delete?await r.delete(i,e):{outcome:"unsupported"}}clearCapabilityCache(){this.capabilities.clear()}probe(r,i){const e=this.capabilities.get(r);if(e)return e;const t=i.probe().catch(()=>({canArchive:!1,canDelete:!1}));return this.capabilities.set(r,t),t}adapter(r){const i=this.options.runner??x;return r==="codex"?{probe:async()=>({canArchive:await _(i,"codex",["--help"],/\barchive\b/),canDelete:!1}),archive:async e=>{if(!h.test(e))return{outcome:"invalid_identity"};const t=this.options.codexArchive,c=b("codex");let s={outcome:"unsupported"};return t?s=await t(e):c&&(s=await I(c,e)),s.outcome==="archived"||s.outcome==="already_absent"||s.outcome==="invalid_identity"||s.outcome==="transient"&&s.errorCode==="native_busy"?s:f(await i("codex",["archive",e],15e3),"archived")}}:r==="gemini"?{probe:async()=>({canArchive:!1,canDelete:await _(i,"gemini",["--help"],/--delete-session\b/)}),delete:async(e,t)=>{if(!h.test(e))return{outcome:"invalid_identity"};const c=await i("gemini",["--delete-session",e],15e3,t?.workDir);return/invalid session identifier/i.test(`${c.stdout}
-${c.stderr}`)?{outcome:"already_absent"}:f(c,"deleted")}}:r==="opencode"?{probe:async()=>({canArchive:!1,canDelete:await _(i,"opencode",["session","delete","--help"],/session delete\s+<sessionID>/i)}),delete:async(e,t)=>k.test(e)?f(await i("opencode",["session","delete",e],15e3,t?.workDir),"deleted"):{outcome:"invalid_identity"}}:r==="cursor"?{probe:async()=>{const e=await i("cursor",["--help"]),t=`${e.stdout}
-${e.stderr}`;return{canArchive:e.code===0&&/\barchive-chat\b/.test(t),canDelete:e.code===0&&/\bdelete-chat\b/.test(t)}},archive:async e=>h.test(e)?f(await i("cursor",["archive-chat",e],15e3),"archived"):{outcome:"invalid_identity"},delete:async e=>h.test(e)?f(await i("cursor",["delete-chat",e],15e3),"deleted"):{outcome:"invalid_identity"}}:{probe:async()=>({canArchive:!1,canDelete:!1})}}}export{S as NativeSessionLifecycleRegistry,x as runNativeLifecycleCommand};
+// @arch docs/features/native-session-deletion-sync.md#四provider-能力基线
+// @test src/__tests__/native-session-lifecycle.test.ts
+import { createInterface } from 'node:readline';
+import fs from 'node:fs';
+import { isAvailableBuiltinAgentType } from '@shennian/wire';
+import { buildAgentProcessEnv } from '../agent-env.js';
+import { resolveBuiltinCommand, spawnAgentCommand, } from '../agents/command-spec.js';
+const OUTPUT_LIMIT = 64 * 1024;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const OPENCODE_SESSION_PATTERN = /^ses_[A-Za-z0-9_-]{6,191}$/;
+function appendLimited(current, chunk) {
+    if (current.length >= OUTPUT_LIMIT)
+        return current;
+    return `${current}${String(chunk)}`.slice(0, OUTPUT_LIMIT);
+}
+export const runNativeLifecycleCommand = async (agentType, args, timeoutMs = 10_000, cwd) => {
+    if (!isAvailableBuiltinAgentType(agentType)) {
+        return {
+            code: null,
+            stdout: '',
+            stderr: '',
+            timedOut: false,
+            spawnErrorCode: 'command_unavailable',
+        };
+    }
+    const spec = resolveBuiltinCommand(agentType);
+    if (!spec) {
+        return {
+            code: null,
+            stdout: '',
+            stderr: '',
+            timedOut: false,
+            spawnErrorCode: 'command_unavailable',
+        };
+    }
+    return await new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let timedOut = false;
+        const proc = spawnAgentCommand(spec, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: buildAgentProcessEnv({ NO_COLOR: '1' }),
+            ...(cwd ? { cwd } : {}),
+        });
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            resolve({ ...result, stdout, stderr, timedOut });
+        };
+        proc.stdout?.on('data', (chunk) => {
+            stdout = appendLimited(stdout, chunk);
+        });
+        proc.stderr?.on('data', (chunk) => {
+            stderr = appendLimited(stderr, chunk);
+        });
+        proc.on('error', (error) => {
+            finish({ code: null, spawnErrorCode: error.code ?? 'spawn_failed' });
+        });
+        proc.on('close', (code) => finish({ code }));
+        const timer = setTimeout(() => {
+            timedOut = true;
+            proc.kill('SIGTERM');
+            setTimeout(() => proc.kill('SIGKILL'), 1_000).unref?.();
+        }, timeoutMs);
+        timer.unref?.();
+    });
+};
+function safeOutput(result) {
+    return `${result.stdout}\n${result.stderr}`.toLowerCase();
+}
+function classifyCommandResult(result, success) {
+    if (result.spawnErrorCode === 'command_unavailable' || result.spawnErrorCode === 'ENOENT') {
+        return { outcome: 'unsupported' };
+    }
+    if (result.timedOut)
+        return { outcome: 'transient', errorCode: 'command_timeout' };
+    const output = safeOutput(result);
+    if (/not found|does not exist|no session|unknown session|already (?:deleted|archived)/.test(output)) {
+        return { outcome: 'already_absent' };
+    }
+    if (/busy|locked|writer|in use|current active session|active turn|temporar|try again|timed out|timeout/.test(output)) {
+        return { outcome: 'transient', errorCode: 'native_busy' };
+    }
+    if (/invalid.*(?:uuid|session|id)|malformed/.test(output)) {
+        return { outcome: 'invalid_identity' };
+    }
+    if (/permission denied|unauthenticated|authentication|forbidden/.test(output)) {
+        return { outcome: 'permanent', errorCode: 'native_auth_required' };
+    }
+    if (result.code === 0)
+        return { outcome: success };
+    return { outcome: 'transient', errorCode: 'native_command_failed' };
+}
+async function commandAdvertises(runner, agentType, args, pattern) {
+    const result = await runner(agentType, args);
+    return !result.timedOut && result.code === 0 && pattern.test(`${result.stdout}\n${result.stderr}`);
+}
+async function codexAppServerArchiveWithSpec(spec, threadId) {
+    return await new Promise((resolve) => {
+        let proc = null;
+        let settled = false;
+        let nextId = 1;
+        let overallTimer = null;
+        const pending = new Map();
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (overallTimer)
+                clearTimeout(overallTimer);
+            for (const request of pending.values())
+                request.reject(new Error('app_server_stopped'));
+            pending.clear();
+            proc?.kill('SIGTERM');
+            resolve(result);
+        };
+        const request = (method, params) => {
+            if (!proc?.stdin)
+                return Promise.reject(new Error('app_server_unavailable'));
+            const id = nextId++;
+            return new Promise((requestResolve, requestReject) => {
+                pending.set(id, { resolve: requestResolve, reject: requestReject });
+                proc.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+            });
+        };
+        try {
+            proc = spawnAgentCommand(spec, ['app-server', '--listen', 'stdio://'], {
+                stdio: ['pipe', 'pipe', 'ignore'],
+                env: buildAgentProcessEnv({ NO_COLOR: '1' }),
+            });
+        }
+        catch {
+            finish({ outcome: 'transient', errorCode: 'app_server_start_failed' });
+            return;
+        }
+        const lines = createInterface({ input: proc.stdout });
+        lines.on('line', (line) => {
+            if (!line.trim())
+                return;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (message.id == null)
+                return;
+            const waiter = pending.get(message.id);
+            if (!waiter)
+                return;
+            pending.delete(message.id);
+            if (message.error) {
+                const error = new Error(message.error.message ?? 'app_server_error');
+                error.rpcCode = message.error.code;
+                waiter.reject(error);
+            }
+            else {
+                waiter.resolve(message.result);
+            }
+        });
+        proc.on('error', () => finish({ outcome: 'transient', errorCode: 'app_server_start_failed' }));
+        proc.on('close', () => {
+            if (!settled)
+                finish({ outcome: 'transient', errorCode: 'app_server_stopped' });
+        });
+        overallTimer = setTimeout(() => finish({ outcome: 'transient', errorCode: 'app_server_timeout' }), 12_000);
+        overallTimer.unref?.();
+        void (async () => {
+            try {
+                await request('initialize', {
+                    clientInfo: { name: 'shennian-native-cleanup', title: 'Shennian', version: '1' },
+                    capabilities: { experimentalApi: true },
+                });
+                await request('thread/archive', { threadId });
+                finish({ outcome: 'archived' });
+            }
+            catch (error) {
+                const rpc = error;
+                const message = rpc.message.toLowerCase();
+                if (/not found|does not exist|already archived|no rollout/.test(message)) {
+                    finish({ outcome: 'already_absent' });
+                }
+                else if (/busy|locked|writer|active turn|in use/.test(message)) {
+                    finish({ outcome: 'transient', errorCode: 'native_busy' });
+                }
+                else if (rpc.rpcCode === -32601 || /method not found|unsupported/.test(message)) {
+                    finish({ outcome: 'unsupported' });
+                }
+                else {
+                    finish({ outcome: 'transient', errorCode: 'app_server_failed' });
+                }
+            }
+        })();
+    });
+}
+export class NativeSessionLifecycleRegistry {
+    options;
+    capabilities = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async execute(agentType, sourceSessionKey, context = {}) {
+        const adapter = this.adapter(agentType);
+        const capability = await this.probe(agentType, adapter);
+        if (capability.canArchive && adapter.archive)
+            return await adapter.archive(sourceSessionKey);
+        if (capability.canDelete && adapter.delete) {
+            if (agentType === 'gemini' && !context.workDir)
+                return { outcome: 'invalid_identity' };
+            if ((agentType === 'gemini' || agentType === 'opencode') && context.workDir) {
+                try {
+                    if (!fs.statSync(context.workDir).isDirectory()) {
+                        return { outcome: 'permanent', errorCode: 'workdir_unavailable' };
+                    }
+                }
+                catch {
+                    return { outcome: 'permanent', errorCode: 'workdir_unavailable' };
+                }
+            }
+            return await this.deleteWithContext(adapter, sourceSessionKey, context);
+        }
+        return { outcome: 'unsupported' };
+    }
+    async deleteWithContext(adapter, sourceSessionKey, context) {
+        if (!adapter.delete)
+            return { outcome: 'unsupported' };
+        return await adapter.delete(sourceSessionKey, context);
+    }
+    clearCapabilityCache() {
+        this.capabilities.clear();
+    }
+    probe(agentType, adapter) {
+        const existing = this.capabilities.get(agentType);
+        if (existing)
+            return existing;
+        const pending = adapter.probe().catch(() => ({ canArchive: false, canDelete: false }));
+        this.capabilities.set(agentType, pending);
+        return pending;
+    }
+    adapter(agentType) {
+        const runner = this.options.runner ?? runNativeLifecycleCommand;
+        if (agentType === 'codex') {
+            return {
+                probe: async () => ({
+                    canArchive: await commandAdvertises(runner, 'codex', ['--help'], /\barchive\b/),
+                    canDelete: false,
+                }),
+                archive: async (sourceSessionKey) => {
+                    if (!UUID_PATTERN.test(sourceSessionKey))
+                        return { outcome: 'invalid_identity' };
+                    const custom = this.options.codexArchive;
+                    const spec = resolveBuiltinCommand('codex');
+                    let appServerResult = { outcome: 'unsupported' };
+                    if (custom)
+                        appServerResult = await custom(sourceSessionKey);
+                    else if (spec)
+                        appServerResult = await codexAppServerArchiveWithSpec(spec, sourceSessionKey);
+                    if (appServerResult.outcome === 'archived' ||
+                        appServerResult.outcome === 'already_absent' ||
+                        appServerResult.outcome === 'invalid_identity' ||
+                        (appServerResult.outcome === 'transient' && appServerResult.errorCode === 'native_busy'))
+                        return appServerResult;
+                    return classifyCommandResult(await runner('codex', ['archive', sourceSessionKey], 15_000), 'archived');
+                },
+            };
+        }
+        if (agentType === 'gemini') {
+            return {
+                probe: async () => ({
+                    canArchive: false,
+                    canDelete: await commandAdvertises(runner, 'gemini', ['--help'], /--delete-session\b/),
+                }),
+                delete: async (sourceSessionKey, context) => {
+                    if (!UUID_PATTERN.test(sourceSessionKey))
+                        return { outcome: 'invalid_identity' };
+                    const result = await runner('gemini', ['--delete-session', sourceSessionKey], 15_000, context?.workDir);
+                    if (/invalid session identifier/i.test(`${result.stdout}\n${result.stderr}`)) {
+                        return { outcome: 'already_absent' };
+                    }
+                    return classifyCommandResult(result, 'deleted');
+                },
+            };
+        }
+        if (agentType === 'opencode') {
+            return {
+                probe: async () => ({
+                    canArchive: false,
+                    canDelete: await commandAdvertises(runner, 'opencode', ['session', 'delete', '--help'], /session delete\s+<sessionID>/i),
+                }),
+                delete: async (sourceSessionKey, context) => {
+                    if (!OPENCODE_SESSION_PATTERN.test(sourceSessionKey)) {
+                        return { outcome: 'invalid_identity' };
+                    }
+                    return classifyCommandResult(await runner('opencode', ['session', 'delete', sourceSessionKey], 15_000, context?.workDir), 'deleted');
+                },
+            };
+        }
+        if (agentType === 'cursor') {
+            return {
+                probe: async () => {
+                    const result = await runner('cursor', ['--help']);
+                    const output = `${result.stdout}\n${result.stderr}`;
+                    return {
+                        canArchive: result.code === 0 && /\barchive-chat\b/.test(output),
+                        canDelete: result.code === 0 && /\bdelete-chat\b/.test(output),
+                    };
+                },
+                archive: async (sourceSessionKey) => {
+                    if (!UUID_PATTERN.test(sourceSessionKey))
+                        return { outcome: 'invalid_identity' };
+                    return classifyCommandResult(await runner('cursor', ['archive-chat', sourceSessionKey], 15_000), 'archived');
+                },
+                delete: async (sourceSessionKey) => {
+                    if (!UUID_PATTERN.test(sourceSessionKey))
+                        return { outcome: 'invalid_identity' };
+                    return classifyCommandResult(await runner('cursor', ['delete-chat', sourceSessionKey], 15_000), 'deleted');
+                },
+            };
+        }
+        return { probe: async () => ({ canArchive: false, canDelete: false }) };
+    }
+}

package/dist/src/session/queue.d.ts

@@ -18,6 +18,9 @@ export type PreparedManagedRoomTurn = {
     managedRoomPromptSnapshot: ManagedRoomPromptSnapshot;
 };
 export type ManagedRoomEnqueueParams = Omit<ChatEnqueueParams, 'protocolVersion' | 'dataEpoch' | 'daemonInstallationId'>;
+export declare class TerminalQueuedChatDispatchError extends Error {
+    constructor(message: string);
+}
 export declare class ChatQueueManager {
     private opts;
     private draining;
@@ -41,6 +44,8 @@ export declare class ChatQueueManager {
     purgeSession(sessionId: string): void;
     private drainIdleQueues;
     private drainNext;
+    private removeBatch;
+    private logLifecycle;
     private dispatchQueuedMessages;
     private isSessionBusy;
     private broadcast;