@gkorepanov/ccodex 0.4.9 → 0.4.11

package/dist/claude/service.js

@@ -1,6 +1,6 @@
 import { join, resolve } from "node:path";
 import { statSync } from "node:fs";
-import { deleteSession, renameSession, } from "@anthropic-ai/claude-agent-sdk";
+import { deleteSession, listSessions, renameSession, } from "@anthropic-ai/claude-agent-sdk";
 import { v7 as uuidv7 } from "uuid";
 import { settingsGeneration } from "../store/HybridStore.js";
 import { SqliteHybridStore } from "../store/sqliteStore.js";
@@ -79,7 +79,11 @@ function threadResponse(record, includeTurns) {
     const { sandboxPolicy: sandbox, effort: reasoningEffort, summary: _summary, collaborationMode: _collaborationMode, personality: _personality, ...settings } = threadSettings(record);
     return {
         ...settings,
-        thread: { ...record.thread, turns: includeTurns ? record.thread.turns : [] },
+        thread: {
+            ...record.thread,
+            canAcceptDirectInput: record.thread.parentThreadId ? false : true,
+            turns: includeTurns ? record.thread.turns : [],
+        },
         runtimeWorkspaceRoots: [record.thread.cwd],
         instructionSources: [],
         sandbox,
@@ -169,10 +173,12 @@ export class ClaudeService {
     threadAdminEffects;
     availabilityProbe;
     skillsChanged;
+    nativeSessionCatalog;
     ephemeralReleases = new Map();
     ephemeralReleaseTimers = new Map();
     removalRetries = new Map();
     terminalAdmins = new Map();
+    settingsUpdates = new Map();
     idleTimer;
     store;
     sessionOutput;
@@ -183,10 +189,13 @@ export class ClaudeService {
     closing = false;
     closePromise;
     standaloneStatusRead;
+    nativeMetadata = new Map();
+    nativeMetadataRead;
+    nativeMetadataReadAt = 0;
     constructor(config, hub, logger, durableStore = new SqliteHybridStore(join(config.dataDir, "state.sqlite")), queryFactory = createClaudeQuery, modelCatalog, metrics = new MetricsRegistry(), transcripts = new SdkTranscriptBrancher(), threadAdminEffects = sdkThreadAdminEffects, shellRunner = new ShellRunner(), availabilityProbe = async () => ({
         provider: "claude",
         state: "ready",
-    }), skillsChanged) {
+    }), skillsChanged, nativeSessionCatalog = () => listSessions()) {
         this.config = config;
         this.hub = hub;
         this.logger = logger;
@@ -197,6 +206,7 @@ export class ClaudeService {
         this.threadAdminEffects = threadAdminEffects;
         this.availabilityProbe = availabilityProbe;
         this.skillsChanged = skillsChanged;
+        this.nativeSessionCatalog = nativeSessionCatalog;
         this.store = new LayeredHybridStore(durableStore);
         const sessionRepository = new ClaudeSessionRepository(this.store);
         this.sessionOutput = new ClaudeOutputAdapter(hub);
@@ -260,14 +270,7 @@ export class ClaudeService {
             }
         }
         this.restartRecovery = this.resumeThreadRemovals(pendingRemovals.map((removal) => removal.rootThreadId))
-            .then(() => this.reconcileAfterRestart(orphanProjectionIds, restartRecoveryRootIds))
-            .then(() => {
-            for (const record of this.store.allThreadRecords()) {
-                if (record.thread.ephemeral && !record.thread.parentThreadId) {
-                    this.scheduleEphemeralRelease(record.thread.id);
-                }
-            }
-        });
+            .then(() => this.reconcileAfterRestart(orphanProjectionIds, restartRecoveryRootIds));
         for (const record of this.store.allThreadRecords()) {
             if (orphanProjectionIds.has(record.thread.id))
                 continue;
@@ -326,7 +329,7 @@ export class ClaudeService {
             throw invalidParams(`Unknown Claude turn '${lastTurnId}'.`);
         const turns = snapshot.record.thread.turns.slice(0, through + 1);
         return {
-            thread: { ...snapshot.record.thread, turns },
+            thread: { ...this.withNativeMetadata(snapshot.record), turns },
             turns,
             settings: threadSettings(snapshot.record),
         };
@@ -337,11 +340,13 @@ export class ClaudeService {
     sideSnapshot(sourceThreadId, targetThreadId, visibleForkedFromId) {
         const record = this.requireRecord(sourceThreadId, false);
         const response = threadResponse(record, false);
+        const source = this.withNativeMetadata(record);
         return {
             ...response,
             thread: {
-                ...record.thread,
+                ...source,
                 id: targetThreadId,
+                sessionId: targetThreadId,
                 forkedFromId: visibleForkedFromId,
                 ephemeral: true,
                 path: null,
@@ -417,6 +422,8 @@ export class ClaudeService {
         if (record.thread.parentThreadId) {
             return {
                 ...threadResponse(record, !resume.excludeTurns),
+                turnsBackwardsCursor: record.thread.turns.length ? "hyb-turn:0" : null,
+                itemsBackwardsCursor: record.thread.turns.some((turn) => turn.items.length) ? "hyb-item:0" : null,
                 initialTurnsPage: resume.initialTurnsPage
                     ? this.turnsPage({
                         threadId,
@@ -431,6 +438,8 @@ export class ClaudeService {
         record = await this.sessions.submit(threadId, { type: "readThread", includeTurns: true });
         return {
             ...threadResponse(record, !resume.excludeTurns),
+            turnsBackwardsCursor: record.thread.turns.length ? "hyb-turn:0" : null,
+            itemsBackwardsCursor: record.thread.turns.some((turn) => turn.items.length) ? "hyb-item:0" : null,
             initialTurnsPage: resume.initialTurnsPage
                 ? this.turnsPage({
                     threadId,
@@ -477,7 +486,7 @@ export class ClaudeService {
         const record = this.store.getThreadRecord(threadId, includeTurns);
         if (!record)
             throw invalidParams(`Unknown Claude thread '${threadId}'.`);
-        return { thread: record.thread };
+        return { thread: this.withNativeMetadata(record) };
     }
     async prepareTurn(params, review) {
         this.requireIndependentThread(params.threadId, "start a turn in");
@@ -794,8 +803,31 @@ export class ClaudeService {
     }
     listThreads(params) {
         return this.store.listThreads(params)
+            .map((thread) => {
+            const record = this.store.getThreadRecord(thread.id, false);
+            return record ? this.withNativeMetadata({ ...record, thread }) : thread;
+        })
             .filter((thread) => !this.pendingThreadRemoval(thread.id) && !this.hub.isSuppressed(thread.id));
     }
+    refreshNativeMetadata() {
+        if (Date.now() - this.nativeMetadataReadAt < 30_000)
+            return Promise.resolve();
+        if (this.nativeMetadataRead)
+            return this.nativeMetadataRead;
+        const read = this.nativeSessionCatalog().then((sessions) => {
+            this.nativeMetadata = new Map(sessions.map((session) => [session.sessionId, session]));
+            this.nativeMetadataReadAt = Date.now();
+        }).catch((error) => {
+            this.logger.warn("claude.catalog.native-metadata-failed", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }).finally(() => {
+            if (this.nativeMetadataRead === read)
+                this.nativeMetadataRead = undefined;
+        });
+        this.nativeMetadataRead = read;
+        return read;
+    }
     async setThreadName(params) {
         const record = this.requireRecord(params.threadId, false);
         if (record.thread.parentThreadId) {
@@ -810,6 +842,14 @@ export class ClaudeService {
                 await this.threadAdminEffects.rename(prepared.record.claudeSessionId, params.name, prepared.record.thread.cwd);
             }
         }, params.name);
+        const native = this.nativeMetadata.get(record.claudeSessionId);
+        if (native)
+            this.nativeMetadata.set(record.claudeSessionId, {
+                ...native,
+                customTitle: params.name,
+                summary: params.name,
+                lastModified: Date.now(),
+            });
         return {};
     }
     updateThreadMetadata(params) {
@@ -921,7 +961,9 @@ export class ClaudeService {
     listItems(params) {
         this.assertThreadAvailable(params.threadId);
         const items = this.store.listTurns(params.threadId)
-            .flatMap((turn) => params.turnId && turn.id !== params.turnId ? [] : turn.items);
+            .flatMap((turn) => params.turnId && turn.id !== params.turnId
+            ? []
+            : turn.items.map((item) => ({ turnId: turn.id, item })));
         const ordered = params.sortDirection === "desc" ? [...items].reverse() : items;
         if (params.cursor && !params.cursor.startsWith("hyb-item:"))
             throw invalidParams("Invalid Claude item cursor.");
@@ -936,10 +978,55 @@ export class ClaudeService {
             backwardsCursor: data.length > 0 ? `hyb-item:${Math.max(0, offset - limit)}` : null,
         };
     }
+    searchOccurrences(params) {
+        this.assertThreadAvailable(params.threadId);
+        const searchTerm = params.searchTerm.trim();
+        if (!searchTerm)
+            throw invalidParams("thread/searchOccurrences requires a non-empty searchTerm.");
+        if (params.cursor && !params.cursor.startsWith("hyb-search:"))
+            throw invalidParams("Invalid Claude search cursor.");
+        const offset = params.cursor ? Number(params.cursor.slice("hyb-search:".length)) : 0;
+        if (!Number.isInteger(offset) || offset < 0)
+            throw invalidParams("Invalid Claude search cursor.");
+        const turns = this.store.listTurns(params.threadId);
+        const needle = searchTerm.toLocaleLowerCase();
+        const occurrences = turns.flatMap((turn, turnIndex) => turn.items.flatMap((item) => {
+            const text = item.type === "userMessage"
+                ? item.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n")
+                : item.type === "agentMessage" && item.phase !== "commentary" ? item.text : undefined;
+            if (text === undefined)
+                return [];
+            const haystack = text.toLocaleLowerCase();
+            const matches = [];
+            for (let start = haystack.indexOf(needle); start >= 0; start = haystack.indexOf(needle, start + needle.length)) {
+                matches.push({
+                    turnId: turn.id,
+                    itemId: item.id,
+                    snippet: text,
+                    snippetMatchRange: { start, end: start + needle.length },
+                    turnCursor: `hyb-turn:${turns.length - 1 - turnIndex}`,
+                });
+            }
+            return matches;
+        }));
+        const limit = Math.max(1, Math.min(params.limit ?? 50, 100));
+        const data = occurrences.slice(offset, offset + limit);
+        return {
+            data,
+            nextCursor: offset + data.length < occurrences.length ? `hyb-search:${offset + data.length}` : null,
+        };
+    }
     async forkThread(params, visibleForkedFromId = params.threadId) {
         if (params.path)
             throw invalidParams("Claude thread forks must use threadId, not a Codex rollout path.");
         this.requireIndependentThread(params.threadId, "fork");
+        if (params.lastTurnId && params.beforeTurnId)
+            throw invalidParams("`beforeTurnId` cannot be combined with `lastTurnId`.");
+        if (params.ephemeral && params.deferGoalContinuation)
+            throw invalidParams("`deferGoalContinuation` cannot be combined with `ephemeral`.");
+        const inheritedGoal = params.deferGoalContinuation
+            ? await this.sessions.submit(params.threadId, { type: "goal", command: { kind: "snapshotFork" } })
+            : undefined;
         const source = await this.sessions.submit(params.threadId, { type: "snapshotBranch" });
         const sourceRecord = source.record;
         const sidePromotion = Boolean((this.config.features?.sideChatPromotion ?? true)
@@ -954,15 +1041,20 @@ export class ClaudeService {
         if (!claudeModelValue)
             throw invalidParams("Cannot fork a Claude thread to a Codex model.");
         const activeSideFork = Boolean(params.ephemeral === true && params.excludeTurns === true
-            && params.threadSource === "user" && !params.lastTurnId);
+            && params.threadSource === "user" && !params.lastTurnId && !params.beforeTurnId);
         if (params.permissions && params.sandbox)
             throw invalidParams("Claude thread fork cannot combine permissions with sandbox.");
         const activeIndex = sourceRecord.thread.turns.findIndex((turn) => turn.status === "inProgress");
         const selectedIndex = params.lastTurnId
             ? sourceRecord.thread.turns.findIndex((turn) => turn.id === params.lastTurnId)
             : -1;
+        const beforeIndex = params.beforeTurnId
+            ? sourceRecord.thread.turns.findIndex((turn) => turn.id === params.beforeTurnId)
+            : -1;
         if (params.lastTurnId && selectedIndex < 0)
             throw invalidParams(`Unknown Claude turn '${params.lastTurnId}'.`);
+        if (params.beforeTurnId && beforeIndex < 0)
+            throw invalidParams(`Unknown Claude turn '${params.beforeTurnId}'.`);
         const selectedTurn = selectedIndex >= 0 ? sourceRecord.thread.turns[selectedIndex] : undefined;
         const selectedBoundary = params.lastTurnId
             ? source.boundaries.find((entry) => entry.turnId === params.lastTurnId)
@@ -974,7 +1066,9 @@ export class ClaudeService {
             ? activeIndex >= 0 ? activeIndex - 1 : sourceRecord.thread.turns.length - 1
             : params.lastTurnId
                 ? selectedIndex
-                : sourceRecord.thread.turns.length - 1;
+                : params.beforeTurnId
+                    ? beforeIndex - 1
+                    : sourceRecord.thread.turns.length - 1;
         if (sidePromotion && through < 0) {
             throw invalidParams("Cannot promote a Claude side chat before it has a completed turn.");
         }
@@ -1008,11 +1102,13 @@ export class ClaudeService {
         }
         const createdAt = nowSeconds();
         const cwd = existingThreadCwd(params.cwd ?? sourceRecord.thread.cwd);
+        const threadId = uuidv7();
         const thread = {
-            ...sourceRecord.thread, id: uuidv7(), ephemeral: params.ephemeral ?? false,
-            sessionId: sourceRecord.thread.sessionId, forkedFromId: visibleForkedFromId,
+            ...sourceRecord.thread, id: threadId, ephemeral: params.ephemeral ?? false,
+            sessionId: threadId, forkedFromId: visibleForkedFromId,
             cwd, modelProvider: "claude", createdAt, updatedAt: createdAt, recencyAt: createdAt,
             status: params.ephemeral ? { type: "idle" } : { type: "notLoaded" },
+            canAcceptDirectInput: true,
             name: params.ephemeral
                 ? sourceRecord.thread.name
                 : sourceRecord.thread.name ? `${sourceRecord.thread.name} (fork)` : null,
@@ -1036,6 +1132,7 @@ export class ClaudeService {
             responseRecord = await this.sessions.submit(thread.id, {
                 type: "commitForkTarget", record, turns: copiedTurns,
                 sourceBoundaries, uuidMap: [...branch.uuidMap],
+                ...(inheritedGoal ? { inheritedGoal } : {}),
             });
         }
         catch (error) {
@@ -1061,7 +1158,7 @@ export class ClaudeService {
             }
         }
         if (sidePromotion)
-            this.scheduleEphemeralRelease(params.threadId);
+            await this.releaseEphemeralThread(params.threadId);
         return threadResponse(responseRecord, !params.excludeTurns);
     }
     async rollbackThread(params) {
@@ -1416,6 +1513,28 @@ export class ClaudeService {
             throw invalidParams(`Unknown Claude thread '${threadId}'.`);
         return record;
     }
+    withNativeMetadata(record) {
+        const native = this.nativeMetadata.get(record.claudeSessionId);
+        if (!native)
+            return {
+                ...record.thread,
+                canAcceptDirectInput: record.thread.parentThreadId ? false : true,
+            };
+        const createdAt = native.createdAt === undefined
+            ? record.thread.createdAt
+            : Math.floor(native.createdAt / 1_000);
+        const updatedAt = Math.floor(native.lastModified / 1_000);
+        return {
+            ...record.thread,
+            canAcceptDirectInput: record.thread.parentThreadId ? false : true,
+            name: (native.customTitle ?? native.summary) || record.thread.name,
+            preview: native.firstPrompt ?? record.thread.preview,
+            cwd: native.cwd ?? record.thread.cwd,
+            createdAt,
+            updatedAt,
+            recencyAt: updatedAt,
+        };
+    }
     requireIndependentThread(threadId, operation) {
         const record = this.requireRecord(threadId, false);
         if (record.thread.parentThreadId) {
@@ -1492,6 +1611,7 @@ export class ClaudeService {
                 updatedAt: createdAt,
                 recencyAt: createdAt,
                 status: { type: "idle" },
+                canAcceptDirectInput: true,
                 path: null,
                 cwd,
                 cliVersion: "claude-code",
@@ -1525,7 +1645,10 @@ export class ClaudeService {
                 ? null
                 : syncedCollaborationMode(settings.collaborationMode, modelPickerId, reasoningEffort),
             outputSchema: null,
-            tokenUsageTotal: { totalTokens: 0, inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, reasoningOutputTokens: 0 },
+            tokenUsageTotal: {
+                totalTokens: 0, inputTokens: 0, cachedInputTokens: 0, cacheWriteInputTokens: 0,
+                outputTokens: 0, reasoningOutputTokens: 0,
+            },
             tokenUsageLast: null,
             modelContextWindow: null,
             providerCostUsdTotal: 0,
@@ -1535,6 +1658,18 @@ export class ClaudeService {
         await this.applySettings({ ...params, effort: turnReasoningEffort(params) }, params.outputSchema ?? null);
     }
     async applySettings(params, outputSchema) {
+        const previous = this.settingsUpdates.get(params.threadId) ?? Promise.resolve();
+        const update = previous.catch(() => undefined).then(() => this.applySettingsNow(params, outputSchema));
+        this.settingsUpdates.set(params.threadId, update);
+        try {
+            await update;
+        }
+        finally {
+            if (this.settingsUpdates.get(params.threadId) === update)
+                this.settingsUpdates.delete(params.threadId);
+        }
+    }
+    async applySettingsNow(params, outputSchema) {
         if (params.permissions && params.sandboxPolicy)
             throw invalidParams("Claude thread settings cannot combine permissions with sandboxPolicy.");
         if (params.effort && !["low", "medium", "high", "xhigh", "max"].includes(params.effort))