sidekick-shared 0.27.4 → 0.27.6

package/dist/processDetection.js

@@ -34,11 +34,13 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ACCOUNT_CONSUMER_REACHABILITY = void 0;
-exports.findRunningProcessesSync = findRunningProcessesSync;
-exports.findRunningProcesses = findRunningProcesses;
 exports.detectRunningAccountConsumers = detectRunningAccountConsumers;
 exports.detectRunningAccountConsumersSync = detectRunningAccountConsumersSync;
 exports.describeAccountConsumer = describeAccountConsumer;
+exports.findRunningProcessesSync = findRunningProcessesSync;
+exports.findRunningProcesses = findRunningProcesses;
+exports.inspectRunningAccountConsumersSync = inspectRunningAccountConsumersSync;
+exports.inspectRunningAccountConsumers = inspectRunningAccountConsumers;
 /**
  * Cross-platform detection of running CLI/app processes that hold provider
  * credentials in memory. Bounded, never throws, never spawns a shell.
@@ -47,6 +49,7 @@ const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
 const PROBE_TIMEOUT_MS = 4000;
 const CLAUDE_NPM_ENTRY = /claude-code[\\/]cli\.js/;
+const CODEX_NPM_ENTRY = /(?:@openai[\\/]codex|codex[\\/]bin)[\\/].*codex\.js/;
 function parseUnixTable(stdout) {
     const rows = [];
     for (const line of stdout.split('\n')) {
@@ -87,6 +90,15 @@ function matchRows(rows, names) {
             CLAUDE_NPM_ENTRY.test(row.args)) {
             name = 'claude';
         }
+        if (!name &&
+            wanted.has('codex') &&
+            /^node(\.exe)?$/i.test(base) &&
+            CODEX_NPM_ENTRY.test(row.args))
+            name = 'codex';
+        if (!name &&
+            wanted.has('Codex') &&
+            /(?:^|[\\/])Codex\.app[\\/]/.test(row.command + ' ' + row.args))
+            name = 'Codex';
         if (name)
             found.push({ pid: row.pid, name, command: row.command });
     }
@@ -101,9 +113,9 @@ function parseOutput(stdout) {
     return process.platform === 'win32' ? parseWindowsCsv(stdout) : parseUnixTable(stdout);
 }
 /** Sync sibling of {@link findRunningProcesses}; blocks up to 4 s. */
-function findRunningProcessesSync(names) {
+function inspectProcessesSync(names) {
     if (names.length === 0)
-        return [];
+        return { ok: true, processes: [] };
     try {
         const { command, args } = probeCommand();
         const result = (0, child_process_1.spawnSync)(command, args, {
@@ -114,16 +126,16 @@ function findRunningProcessesSync(names) {
             windowsHide: true,
         });
         if (result.error || result.status !== 0)
-            return [];
-        return matchRows(parseOutput(String(result.stdout ?? '')), names);
+            return { ok: false, processes: [] };
+        return { ok: true, processes: matchRows(parseOutput(String(result.stdout ?? '')), names) };
     }
     catch {
-        return [];
+        return { ok: false, processes: [] };
     }
 }
-function findRunningProcesses(names) {
+function inspectProcesses(names) {
     if (names.length === 0)
-        return Promise.resolve([]);
+        return Promise.resolve({ ok: true, processes: [] });
     return new Promise((resolve) => {
         try {
             const { command, args } = probeCommand();
@@ -134,11 +146,14 @@ function findRunningProcesses(names) {
                 windowsHide: true,
                 maxBuffer: 16 * 1024 * 1024,
             }, (error, stdout) => {
-                resolve(error ? [] : matchRows(parseOutput(String(stdout ?? '')), names));
+                resolve({
+                    ok: !error,
+                    processes: error ? [] : matchRows(parseOutput(String(stdout ?? '')), names),
+                });
             });
         }
         catch {
-            resolve([]);
+            resolve({ ok: false, processes: [] });
         }
     });
 }
@@ -208,3 +223,21 @@ function detectRunningAccountConsumersSync(provider) {
 function describeAccountConsumer(kind, pids = []) {
     return toConsumer(kind, pids);
 }
+/** Compatibility wrappers keep the established best-effort list API. */
+function findRunningProcessesSync(names) {
+    return inspectProcessesSync(names).processes;
+}
+async function findRunningProcesses(names) {
+    return (await inspectProcesses(names)).processes;
+}
+/** Safety decisions must distinguish a failed process scan from an empty one. */
+function inspectRunningAccountConsumersSync(provider) {
+    const kinds = kindsForProvider(provider);
+    const result = inspectProcessesSync(kinds.map((kind) => CONSUMER_PROCESS_NAMES[kind]));
+    return { ok: result.ok, consumers: groupConsumers(result.processes, kinds) };
+}
+async function inspectRunningAccountConsumers(provider) {
+    const kinds = kindsForProvider(provider);
+    const result = await inspectProcesses(kinds.map((kind) => CONSUMER_PROCESS_NAMES[kind]));
+    return { ok: result.ok, consumers: groupConsumers(result.processes, kinds) };
+}

package/dist/promptHistory.d.ts

@@ -19,6 +19,7 @@
  * the prompt is returned again under the same identity once its first
  * answering call brings model or usage (`metadataStatus` says how settled).
  */
+import * as fs from 'fs';
 import { type HumanPromptProvider } from './humanPrompt';
 export type PromptHistoryProvider = HumanPromptProvider;
 export type PromptHistoryBound = 'maxSessions' | 'maxFileBytes' | 'maxTotalBytes' | 'maxEntries' | 'deadline' | 'aborted';
@@ -213,9 +214,74 @@ export interface PromptHistoryResult {
     /** A bound left bytes or files unread; call again with the cursor to continue. */
     hasMore: boolean;
 }
+/** @internal */
+export declare const DEFAULT_BOUNDS: Required<PromptHistoryBounds>;
 /** Test hooks; not part of the public entry points. */
 export declare const __promptHistoryTesting: {
     setReadChunkBytes(bytes: number | null): void;
 };
+/** @internal */
+export interface Candidate {
+    provider: PromptHistoryProvider;
+    sessionId: string;
+    filePath: string;
+    key: string;
+}
+/**
+ * Sees every parsed record of a file after the scanner, with the ordinal of the
+ * latest human prompt so far (-1 before the first). Used for whole-session reads.
+ * @internal
+ */
+export type RecordObserver = (record: Record<string, unknown>, info: {
+    ordinal: number;
+    lineOffset: number;
+}) => void;
+/** @internal */
+export interface ScanContext {
+    roots: string[];
+    sinceMs: number | null;
+    stats: PromptHistoryStats;
+    realpaths: Map<string, string | null>;
+    bounds: Required<PromptHistoryBounds>;
+    shouldStop: () => PromptHistoryBound | null;
+    /** Entries already collected from earlier files in this call. */
+    entriesSoFar: () => number;
+    exclude: (exclusion: PromptHistoryExclusion) => void;
+    observe?: RecordObserver;
+}
+/** @internal */
+export interface FileBudget {
+    bytes: number;
+    /** Which bound `bytes` came from. */
+    bound: 'maxFileBytes' | 'maxTotalBytes';
+    /** First file of the call: may finish its first record even past the budget. */
+    forceProgress: boolean;
+}
+/** @internal */
+export interface FileOutcome {
+    entries: PromptHistoryEntry[];
+    /** The pass moved the file's offset forward. */
+    progressed: boolean;
+    /** New cursor state, or undefined to drop it (rewrite found mid-pass). */
+    session: PromptHistoryCursorSession | undefined;
+    bytesRead: number;
+    stoppedBy: PromptHistoryBound | null;
+    notInteractive: boolean;
+    inScope: number;
+    outOfScope: number;
+}
 /** Collect human-typed prompts from Claude Code and Codex logs under the given roots. */
 export declare function collectPromptHistory(options: CollectPromptHistoryOptions): Promise<PromptHistoryResult>;
+/** @internal */
+export declare function emptyStats(): PromptHistoryStats;
+/** @internal */
+export declare function compareStrings(left: string, right: string): number;
+/** @internal */
+export declare function resolveRoots(workspacePaths: string[], includeWorktrees: boolean, realpaths: Map<string, string | null>): {
+    roots: string[];
+    listingRoots: string[];
+};
+/** @internal */
+export declare function listCandidates(providers: PromptHistoryProvider[], listingRoots: string[], sinceMs: number | null): Promise<Candidate[]>;
+/** @internal */
+export declare function scanFile(candidate: Candidate, stat: fs.Stats, prior: PromptHistoryCursorSession | undefined, budget: FileBudget, context: ScanContext): Promise<FileOutcome>;

package/dist/promptHistory.js

@@ -54,8 +54,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__promptHistoryTesting = void 0;
+exports.__promptHistoryTesting = exports.DEFAULT_BOUNDS = void 0;
 exports.collectPromptHistory = collectPromptHistory;
+exports.emptyStats = emptyStats;
+exports.compareStrings = compareStrings;
+exports.resolveRoots = resolveRoots;
+exports.listCandidates = listCandidates;
+exports.scanFile = scanFile;
 const crypto_1 = require("crypto");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -63,7 +68,8 @@ const humanPrompt_1 = require("./humanPrompt");
 const sessionPathResolver_1 = require("./parsers/sessionPathResolver");
 const claudeCode_1 = require("./providers/claudeCode");
 const codex_1 = require("./providers/codex");
-const DEFAULT_BOUNDS = {
+/** @internal */
+exports.DEFAULT_BOUNDS = {
     maxSessions: 1000,
     maxFileBytes: 16 * 1024 * 1024,
     maxTotalBytes: 256 * 1024 * 1024,
@@ -85,22 +91,10 @@ exports.__promptHistoryTesting = {
 };
 /** Collect human-typed prompts from Claude Code and Codex logs under the given roots. */
 async function collectPromptHistory(options) {
-    const bounds = { ...DEFAULT_BOUNDS, ...definedBounds(options.bounds) };
+    const bounds = { ...exports.DEFAULT_BOUNDS, ...definedBounds(options.bounds) };
     const startedAt = Date.now();
     const boundsHit = new Set();
-    const stats = {
-        sessionsScanned: 0,
-        sessionsSkippedUnchanged: 0,
-        sessionsOutOfScope: 0,
-        filesOverSizeLimit: 0,
-        sessionsWithBacklog: 0,
-        sessionsRewritten: 0,
-        sessionsNotInteractive: 0,
-        recordsOverSizeLimit: 0,
-        recordsMalformed: 0,
-        promptsMissingTimestamp: 0,
-        promptsOutOfScope: 0,
-    };
+    const stats = emptyStats();
     const { sessions: previous, next: previousNext } = acceptedCursor(options.cursor);
     const cursor = { version: 3, sessions: { ...previous } };
     const entries = [];
@@ -231,11 +225,27 @@ async function collectPromptHistory(options) {
     }
     return finish();
 }
+/** @internal */
+function emptyStats() {
+    return {
+        sessionsScanned: 0,
+        sessionsSkippedUnchanged: 0,
+        sessionsOutOfScope: 0,
+        filesOverSizeLimit: 0,
+        sessionsWithBacklog: 0,
+        sessionsRewritten: 0,
+        sessionsNotInteractive: 0,
+        recordsOverSizeLimit: 0,
+        recordsMalformed: 0,
+        promptsMissingTimestamp: 0,
+        promptsOutOfScope: 0,
+    };
+}
 function definedBounds(bounds) {
     const result = {};
     if (!bounds)
         return result;
-    for (const key of Object.keys(DEFAULT_BOUNDS)) {
+    for (const key of Object.keys(exports.DEFAULT_BOUNDS)) {
         const value = bounds[key];
         if (typeof value === 'number' && !Number.isNaN(value))
             result[key] = Math.max(0, value);
@@ -321,6 +331,7 @@ function compareEntries(left, right) {
         compareStrings(left.sessionId, right.sessionId) ||
         left.ordinal - right.ordinal);
 }
+/** @internal */
 function compareStrings(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
@@ -342,6 +353,7 @@ function realpathOrNull(input, cache) {
     cache.set(input, resolved);
     return resolved;
 }
+/** @internal */
 function resolveRoots(workspacePaths, includeWorktrees, realpaths) {
     const roots = new Set();
     const listingRoots = new Set();
@@ -385,6 +397,7 @@ function scopedCwd(cwd, roots, realpaths) {
     }
     return null;
 }
+/** @internal */
 async function listCandidates(providers, listingRoots, sinceMs) {
     const byPath = new Map();
     const listOptions = sinceMs !== null ? { since: sinceMs } : {};
@@ -468,6 +481,7 @@ async function verifyFile(handle, size, session) {
     }
     return { head: { bytes: head.length, hash: hashBytes(head) }, bytesRead };
 }
+/** @internal */
 async function scanFile(candidate, stat, prior, budget, context) {
     const handle = await fs.promises.open(candidate.filePath, 'r');
     try {
@@ -728,7 +742,12 @@ function acceptLine(line, lineOffset, lineBytes, scanner, context, candidate) {
     }
     if (typeof record !== 'object' || record === null)
         return 'ok';
-    return scanner.accept(record, lineOffset, lineBytes);
+    const row = record;
+    const accepted = scanner.accept(row, lineOffset, lineBytes);
+    if (accepted === 'ok' && context.observe) {
+        context.observe(row, { ordinal: scanner.lastOrdinal(), lineOffset });
+    }
+    return accepted;
 }
 /** Shared per-file prompt bookkeeping for both providers. */
 class LineScanner {

package/dist/schemas/accountManager.d.ts

@@ -143,6 +143,7 @@ export declare const accountHealthSidecarSchema: z.ZodObject<{
         "api-key": "api-key";
         oauth: "oauth";
     }>>;
+    refreshFp: z.ZodOptional<z.ZodString>;
     source: z.ZodEnum<{
         login: "login";
         "live-sync": "live-sync";
@@ -310,6 +311,13 @@ export declare const providerSyncReportSchema: z.ZodObject<{
     folded: z.ZodOptional<z.ZodString>;
     repointed: z.ZodOptional<z.ZodString>;
     merged: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    demoted: z.ZodOptional<z.ZodString>;
+    repaired: z.ZodOptional<z.ZodString>;
+    journal: z.ZodOptional<z.ZodEnum<{
+        finished: "finished";
+        "rolled-back": "rolled-back";
+        cleared: "cleared";
+    }>>;
     skipped: z.ZodOptional<z.ZodString>;
     warnings: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
@@ -322,6 +330,13 @@ export declare const syncReportSchema: z.ZodObject<{
         folded: z.ZodOptional<z.ZodString>;
         repointed: z.ZodOptional<z.ZodString>;
         merged: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        demoted: z.ZodOptional<z.ZodString>;
+        repaired: z.ZodOptional<z.ZodString>;
+        journal: z.ZodOptional<z.ZodEnum<{
+            finished: "finished";
+            "rolled-back": "rolled-back";
+            cleared: "cleared";
+        }>>;
         skipped: z.ZodOptional<z.ZodString>;
         warnings: z.ZodArray<z.ZodString>;
     }, z.core.$strip>;
@@ -333,6 +348,13 @@ export declare const syncReportSchema: z.ZodObject<{
         folded: z.ZodOptional<z.ZodString>;
         repointed: z.ZodOptional<z.ZodString>;
         merged: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        demoted: z.ZodOptional<z.ZodString>;
+        repaired: z.ZodOptional<z.ZodString>;
+        journal: z.ZodOptional<z.ZodEnum<{
+            finished: "finished";
+            "rolled-back": "rolled-back";
+            cleared: "cleared";
+        }>>;
         skipped: z.ZodOptional<z.ZodString>;
         warnings: z.ZodArray<z.ZodString>;
     }, z.core.$strip>;

package/dist/schemas/accountManager.js

@@ -107,6 +107,7 @@ exports.accountHealthSidecarSchema = zod_1.z.object({
     lastRefreshAt: zod_1.z.number().optional(),
     hasRefreshToken: zod_1.z.boolean().optional(),
     authMode: zod_1.z.enum(['chatgpt', 'api-key', 'oauth']).optional(),
+    refreshFp: zod_1.z.string().optional(),
     source: exports.accountHealthSourceSchema,
 });
 exports.accountHealthSchema = zod_1.z.object({
@@ -178,6 +179,9 @@ exports.providerSyncReportSchema = zod_1.z.object({
     folded: zod_1.z.string().optional(),
     repointed: zod_1.z.string().optional(),
     merged: zod_1.z.array(zod_1.z.string()).optional(),
+    demoted: zod_1.z.string().optional(),
+    repaired: zod_1.z.string().optional(),
+    journal: zod_1.z.enum(['finished', 'rolled-back', 'cleared']).optional(),
     skipped: zod_1.z.string().optional(),
     warnings: zod_1.z.array(zod_1.z.string()),
 });

package/dist/schemas/assistantTurn.d.ts

@@ -7,8 +7,8 @@
 import { z } from 'zod';
 export declare const assistantTurnEventTypeSchema: z.ZodEnum<{
     error: "error";
-    text: "text";
     status: "status";
+    text: "text";
     tool_use: "tool_use";
     tool_result: "tool_result";
     progress: "progress";
@@ -18,8 +18,8 @@ export declare const assistantTurnEventTypeSchema: z.ZodEnum<{
 export declare const assistantTurnEventSchema: z.ZodObject<{
     eventType: z.ZodEnum<{
         error: "error";
-        text: "text";
         status: "status";
+        text: "text";
         tool_use: "tool_use";
         tool_result: "tool_result";
         progress: "progress";

package/dist/sessionPromptHistory.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Node-only whole-session view of prompt history: every human prompt of a
+ * Claude Code or Codex session, grouped by session, for consumers that
+ * classify a session as a whole (intent, conflict, issues).
+ *
+ * Sessions are read from the start with the same scanners as
+ * `collectPromptHistory()`, so scope rules, prompt text, first-call model and
+ * usage, and ordinals are identical. The replies and interaction signals that
+ * the prompt filter leaves out are opt-in through `include`.
+ *
+ * There is no cursor: each call returns whole sessions. A bound that stops a
+ * call lists the sessions it did not read in `unread`; passing them back as
+ * `sessionIds` continues. Scope fails closed as in `collectPromptHistory()`,
+ * and replies or signals that belong to an out-of-scope prompt are dropped.
+ */
+import { type PromptHistoryEntry, type PromptHistoryExclusion, type PromptHistoryProvider } from './promptHistory';
+import { type PromptHistoryReply, type PromptHistorySignal } from './sessionPromptSignals';
+export interface SessionPromptHistoryInclude {
+    /** Interrupts, rejected and failed tool calls, compactions, API errors, rollbacks. */
+    signals?: boolean;
+    /** The agent's last text for each prompt's turn. */
+    replies?: boolean;
+}
+export interface SessionPromptHistoryBounds {
+    /** Session files read in one call. Default 1000. */
+    maxSessions?: number;
+    /** Bytes read from one session; a longer session is returned `truncated`. Default 256 MiB. */
+    maxSessionBytes?: number;
+    /** Bytes read across all sessions in one call. Default 256 MiB. */
+    maxTotalBytes?: number;
+    /** Largest single log record that is parsed. Default 16 MiB. */
+    maxRecordBytes?: number;
+    /** Wall-clock budget for the call. Default 60 000 ms. */
+    deadlineMs?: number;
+}
+export interface CollectSessionPromptHistoryOptions {
+    /** Absolute workspace roots; realpath-normalized internally. */
+    workspacePaths: string[];
+    /** Add git worktree siblings of each root. Default true. */
+    includeWorktrees?: boolean;
+    /** Default both. */
+    providers?: PromptHistoryProvider[];
+    /** Only these sessions (exact ids). */
+    sessionIds?: string[];
+    /** Only sessions whose file changed at or after this. Each comes back whole. */
+    since?: Date;
+    /** Return at most this many sessions, most recently modified first. */
+    limit?: number;
+    /** Opt-in content beyond the prompts. */
+    include?: SessionPromptHistoryInclude;
+    bounds?: SessionPromptHistoryBounds;
+    signal?: AbortSignal;
+}
+export interface PromptHistorySessionPrompt extends Omit<PromptHistoryEntry, 'provider' | 'sessionId'> {
+    /** With `include.replies`: the agent's last text for this prompt's turn. */
+    reply?: PromptHistoryReply;
+}
+export interface PromptHistorySession {
+    provider: PromptHistoryProvider;
+    sessionId: string;
+    /** Earliest timestamp in the session log. */
+    startedAt: string;
+    /** Latest timestamp in the session log. */
+    lastActivityAt: string;
+    /** Distinct prompt working directories, in order of first use. */
+    cwds: string[];
+    /** Distinct prompt git branches, in order of first use. */
+    gitBranches: string[];
+    /** Distinct models that answered a prompt, in order of first use. */
+    models: string[];
+    /** Every human prompt in scope, by ordinal. */
+    prompts: PromptHistorySessionPrompt[];
+    /** With `include.signals`: interaction signals in log order. */
+    signals?: PromptHistorySignal[];
+    /** Read to the end with no dropped prompts and no excluded records. */
+    complete: boolean;
+    /** `maxSessionBytes` stopped the read; later prompts are missing. */
+    truncated: boolean;
+    /** Prompts left out because their cwd was out of scope or they had no timestamp. */
+    droppedPrompts: number;
+    /** Records left out as oversized or malformed (see `exclusions`). */
+    excludedRecords: number;
+}
+export interface PromptHistorySessionRef {
+    provider: PromptHistoryProvider;
+    sessionId: string;
+}
+export type SessionPromptHistoryBound = 'maxSessions' | 'maxSessionBytes' | 'maxTotalBytes' | 'deadline' | 'aborted';
+export interface SessionPromptHistoryStats {
+    /** Session files that matched the provider, id, and `since` filters. */
+    sessionsMatched: number;
+    sessionsScanned: number;
+    sessionsReturned: number;
+    /** Scanned sessions with no human prompt at all. */
+    sessionsWithoutPrompts: number;
+    /** Scanned sessions with human prompts but none inside the allowed roots. */
+    sessionsOutOfScope: number;
+    /** Codex sessions skipped as non-interactive (subagent, fork, unknown source). */
+    sessionsNotInteractive: number;
+    sessionsTruncated: number;
+    recordsOverSizeLimit: number;
+    recordsMalformed: number;
+    promptsMissingTimestamp: number;
+    promptsOutOfScope: number;
+}
+export interface SessionPromptHistoryResult {
+    /** Most recent activity first. */
+    sessions: PromptHistorySession[];
+    /**
+     * Sessions this call did not read, because a bound stopped it or the file
+     * changed while it was read; pass them as `sessionIds` to continue.
+     */
+    unread: PromptHistorySessionRef[];
+    boundsHit: SessionPromptHistoryBound[];
+    /** Permanent exclusions found in this call (at most 1000; stats count all). */
+    exclusions: PromptHistoryExclusion[];
+    stats: SessionPromptHistoryStats;
+}
+/** Collect every human prompt of each matching session, grouped by session. */
+export declare function collectSessionPromptHistory(options: CollectSessionPromptHistoryOptions): Promise<SessionPromptHistoryResult>;