dsh-reference-anything 0.2.0 → 0.2.1

package/lib/contract.d.ts

@@ -99,6 +99,17 @@ export declare const openCliDiscoverySchema: z.ZodReadonly<z.ZodObject<{
     version: z.ZodString;
     error: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
+export declare const packageUpdateStatusSchema: z.ZodReadonly<z.ZodObject<{
+    currentVersion: z.ZodString;
+    latestVersion: z.ZodString;
+    updateAvailable: z.ZodBoolean;
+    checkedAt: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+export declare const packageUpdateResultSchema: z.ZodReadonly<z.ZodObject<{
+    version: z.ZodString;
+    restartRequired: z.ZodBoolean;
+}, z.core.$strip>>;
 export declare const providerStatsSchema: z.ZodReadonly<z.ZodObject<{
     provider: z.ZodEnum<{
         chatgpt: "chatgpt";

package/lib/contract.js

@@ -26,6 +26,13 @@ export const browserProfileSchema = z.object({ id: z.string(), alias: z.string()
 export const openCliDiscoverySchema = z.object({
     found: z.boolean(), executable: z.string(), version: z.string(), error: z.string().optional(),
 }).readonly();
+export const packageUpdateStatusSchema = z.object({
+    currentVersion: z.string(), latestVersion: z.string(), updateAvailable: z.boolean(),
+    checkedAt: z.number().int().nonnegative(), error: z.string().optional(),
+}).readonly();
+export const packageUpdateResultSchema = z.object({
+    version: z.string(), restartRequired: z.boolean(),
+}).readonly();
 export const providerStatsSchema = z.object({
     provider: providerSchema, conversations: z.number().int().nonnegative(), lastSyncedAt: z.string(),
     status: z.enum(['ready', 'syncing', 'error', 'empty']), error: z.string().optional(),
@@ -74,6 +81,9 @@ export const REFERENCE_ANYTHING_INVOCATIONS = [
     descriptor('installOpenCli', [], strict('OpenCliDiscovery', openCliDiscoverySchema), true),
     descriptor('installAdapter', [], strict('Boolean', z.boolean()), true),
     descriptor('restartDaemon', [], strict('Boolean', z.boolean()), true),
+    descriptor('updateStatus', [], strict('PackageUpdateStatus', packageUpdateStatusSchema), true),
+    descriptor('checkUpdate', [], strict('PackageUpdateStatus', packageUpdateStatusSchema), true),
+    descriptor('installUpdate', [], strict('PackageUpdateResult', packageUpdateResultSchema), true),
     descriptor('stats', [], strict('ProviderStats[]', z.array(providerStatsSchema))),
     descriptor('syncStart', [{ name: 'input', wire: 'input', source: 'json', codec: strict('SyncStart', syncStartSchema) }], strict('JobId', z.string())),
     descriptor('syncStatus', [{ name: 'input', wire: 'input', source: 'json', codec: strict('JobInput', jobInputSchema) }], strict('SyncStatus?', syncStatusSchema.optional())),

package/lib/host.d.ts

@@ -26,6 +26,9 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
     installOpenCli(signal: AbortSignal): Promise<import("./opencli.ts").OpenCliDiscovery>;
     installAdapter(signal: AbortSignal): Promise<boolean>;
     restartDaemon(signal: AbortSignal): Promise<boolean>;
+    updateStatus(signal: AbortSignal): Promise<import("./update.ts").PackageUpdateStatus>;
+    checkUpdate(signal: AbortSignal): Promise<import("./update.ts").PackageUpdateStatus>;
+    installUpdate(signal: AbortSignal): Promise<import("./update.ts").PackageUpdateResult>;
     stats(): import("./store/store.ts").ProviderStats[];
     syncStart(input: {
         providers: ChatProvider[];

package/lib/host.js

@@ -18,6 +18,9 @@ export class ReferenceAnythingRemote extends TypertRemoteService {
     installOpenCli(signal) { return this.ctx.referenceChatHistory.installOpenCli(signal); }
     installAdapter(signal) { return this.ctx.referenceChatHistory.installAdapter(signal); }
     restartDaemon(signal) { return this.ctx.referenceChatHistory.restartDaemon(signal); }
+    updateStatus(signal) { return this.ctx.referenceChatHistory.updateStatus(signal); }
+    checkUpdate(signal) { return this.ctx.referenceChatHistory.checkUpdate(signal); }
+    installUpdate(signal) { return this.ctx.referenceChatHistory.installUpdate(signal); }
     stats() { return this.ctx.referenceChatHistory.stats(); }
     syncStart(input) {
         return this.ctx.referenceChatHistory.sync.start(input.providers, input.mode);

package/lib/opencli.d.ts

@@ -1,7 +1,7 @@
 import type { ChatProvider } from './store/spec.ts';
 import type { ProviderConversationRow, ProviderTurnRow } from './store/store.ts';
 export declare const MIN_OPENCLI_VERSION = "1.8.6";
-export declare const MIN_ADAPTER_VERSION = "0.2.0";
+export declare const MIN_ADAPTER_VERSION = "0.2.1";
 export declare const OPENCLI_NPM_PACKAGE = "@jackwener/opencli";
 export type OpenCliErrorCode = 'EXTENSION_NOT_CONNECTED' | 'PROVIDER_TIMEOUT' | 'PROVIDER_NOT_LOGGED_IN' | 'PROVIDER_ACCOUNT_MISMATCH' | 'OPENCLI_CONFIGURATION' | 'OPENCLI_OUTPUT_TOO_LARGE' | 'OPENCLI_FAILED' | 'OPENCLI_INSTALL_FAILED';
 export declare class OpenCliError extends Error {

package/lib/opencli.js

@@ -5,13 +5,20 @@ import { promisify } from 'node:util';
 import { createHash } from 'node:crypto';
 const execFile = promisify(nodeExecFile);
 export const MIN_OPENCLI_VERSION = '1.8.6';
-export const MIN_ADAPTER_VERSION = '0.2.0';
+export const MIN_ADAPTER_VERSION = '0.2.1';
 export const OPENCLI_NPM_PACKAGE = '@jackwener/opencli';
 const SITE = {
     chatgpt: 'dsh-chatgpt', claude: 'dsh-claude', gemini: 'dsh-gemini',
     deepseek: 'dsh-deepseek', grok: 'dsh-grok', kimi: 'dsh-kimi',
 };
 const REQUIRED_ADAPTER_COMMANDS = ['chatgpt', 'claude', 'gemini', 'deepseek', 'grok', 'kimi'];
+/**
+ * A persistent OpenCLI site session owns one mutable browser tab. Serialize
+ * commands that target the same executable/profile/site across runner
+ * instances so concurrent detail workers cannot navigate that tab over one
+ * another. Different provider sites still run in parallel.
+ */
+const SITE_COMMAND_TAILS = new Map();
 export class OpenCliError extends Error {
     code;
     constructor(message, code, options) {
@@ -185,19 +192,25 @@ export class OpenCliRunner {
         }
     }
     async json(site, operation, args, signal) {
-        // Pin adapter traffic to a background tab. OpenCLI otherwise lets the
-        // process-wide OPENCLI_WINDOW environment variable override the adapter's
-        // defaultWindowMode, which could make an unattended sync steal focus.
-        const stdout = await this.raw([site, operation, ...args, '--window', 'background', '-f', 'json'], signal);
-        try {
-            const parsed = JSON.parse(stdout);
-            if (!Array.isArray(parsed) || parsed.some(row => !row || typeof row !== 'object' || Array.isArray(row)))
-                throw new Error('expected object array');
-            return parsed;
-        }
-        catch (error) {
-            throw new OpenCliError('OpenCLI returned malformed JSON', 'OPENCLI_CONFIGURATION', { cause: error });
-        }
+        const queueKey = [this.executable, ...this.prefixArgs, this.profile, site].join('\0');
+        return serializeSiteCommand(queueKey, async () => {
+            // Pin adapter traffic to one persistent background session. OpenCLI
+            // otherwise lets caller flags override the adapter lifecycle metadata,
+            // which could release its tab or make an unattended sync steal focus.
+            const stdout = await this.raw([
+                site, operation, ...args,
+                '--site-session', 'persistent', '--window', 'background', '-f', 'json',
+            ], signal);
+            try {
+                const parsed = JSON.parse(stdout);
+                if (!Array.isArray(parsed) || parsed.some(row => !row || typeof row !== 'object' || Array.isArray(row)))
+                    throw new Error('expected object array');
+                return parsed;
+            }
+            catch (error) {
+                throw new OpenCliError('OpenCLI returned malformed JSON', 'OPENCLI_CONFIGURATION', { cause: error });
+            }
+        });
     }
     async raw(args, signal) {
         const invocation = resolveInvocation(this.executable);
@@ -224,6 +237,19 @@ export class OpenCliRunner {
         }
     }
 }
+async function serializeSiteCommand(key, task) {
+    const previous = SITE_COMMAND_TAILS.get(key) ?? Promise.resolve();
+    const current = previous.then(task, task);
+    const settled = current.then(() => undefined, () => undefined);
+    SITE_COMMAND_TAILS.set(key, settled);
+    try {
+        return await current;
+    }
+    finally {
+        if (SITE_COMMAND_TAILS.get(key) === settled)
+            SITE_COMMAND_TAILS.delete(key);
+    }
+}
 /** Locate a working OpenCLI without asking a command-line newcomer for PATH details. */
 export async function discoverOpenCli(configured = 'opencli', signal) {
     const candidates = openCliCandidates(configured);

package/lib/sources/web-chat/index.d.ts

@@ -5,6 +5,7 @@ import type { ChatProvider, SettingsRecord } from '../../store/spec.ts';
 import { ConversationStore, type MatchedVia } from '../../store/store.ts';
 import { ConversationSyncManager } from '../../sync/index.ts';
 import { type OpenCliDiscovery } from '../../opencli.ts';
+import { type PackageUpdateResult, type PackageUpdateStatus } from '../../update.ts';
 import { parseProviderQuery } from '../../search.ts';
 export { parseProviderQuery };
 export declare const name = "reference-web-chat";
@@ -51,6 +52,7 @@ export default class WebChatHistoryService extends Service implements ReferenceS
     private syncValue?;
     private autoSyncInterval?;
     private autoSyncCatchUp?;
+    private readonly packageUpdates;
     private readonly liveAttachments;
     constructor(ctx: Context, config?: Config);
     protected [Service.init](): Promise<void>;
@@ -84,6 +86,9 @@ export default class WebChatHistoryService extends Service implements ReferenceS
     /** Durable per-provider sync status, independent of any single in-flight job. */
     syncStates(): import("../../store/store.ts").ProviderSyncState[];
     getSettings(): SettingsRecord;
+    updateStatus(signal?: AbortSignal): Promise<PackageUpdateStatus>;
+    checkUpdate(signal?: AbortSignal): Promise<PackageUpdateStatus>;
+    installUpdate(signal?: AbortSignal): Promise<PackageUpdateResult>;
     restartDaemon(signal?: AbortSignal): Promise<boolean>;
     discoverOpenCli(signal?: AbortSignal): Promise<OpenCliDiscovery>;
     installOpenCli(signal?: AbortSignal): Promise<OpenCliDiscovery>;

package/lib/sources/web-chat/index.js

@@ -4,6 +4,7 @@ import { providerSchema, referenceAnythingDomainSpec, settingsRecordSchema } fro
 import { ConversationStore } from "../../store/store.js";
 import { ConversationSyncManager } from "../../sync/index.js";
 import { OpenCliError, OpenCliRunner, discoverOpenCli, installOpenCli as installOpenCliPackage } from "../../opencli.js";
+import { PackageUpdateManager } from "../../update.js";
 import { ReferenceAnythingError } from "../../errors.js";
 import { parseProviderQuery } from "../../search.js";
 export { parseProviderQuery };
@@ -26,6 +27,7 @@ export default class WebChatHistoryService extends Service {
     syncValue;
     autoSyncInterval;
     autoSyncCatchUp;
+    packageUpdates = new PackageUpdateManager();
     liveAttachments = new Map();
     constructor(ctx, config = {}) {
         super(ctx, 'referenceChatHistory');
@@ -47,6 +49,13 @@ export default class WebChatHistoryService extends Service {
             timeoutMs: this.config.timeoutMs, maxStdoutBytes: this.config.maxStdoutBytes,
         }), this.ctx.logger);
         await this.store.collectExpired();
+        const updateAbort = new AbortController();
+        this.ctx.effect(() => () => { updateAbort.abort(); }, 'reference-web-chat.updateCheckCleanup');
+        void this.packageUpdates.check(updateAbort.signal).then(status => {
+            if (status.updateAvailable) {
+                this.ctx.logger.info(`reference anything update available: ${status.currentVersion} -> ${status.latestVersion}`);
+            }
+        });
         this.ctx.references.registerSource(this);
         this.ctx.effect(() => () => { this.clearAutoSync(); }, 'reference-web-chat.autoSyncCleanup');
         this.armAutoSync();
@@ -182,6 +191,13 @@ export default class WebChatHistoryService extends Service {
     /** Durable per-provider sync status, independent of any single in-flight job. */
     syncStates() { return this.store.syncStateSummary(); }
     getSettings() { return this.store.settings; }
+    updateStatus(signal) { return this.packageUpdates.status(signal); }
+    checkUpdate(signal) { return this.packageUpdates.check(signal); }
+    async installUpdate(signal) {
+        if (this.sync.isRunning())
+            throw new ReferenceAnythingError('wait for the current conversation sync to finish before updating', 'REFERENCE_SYNC_IN_PROGRESS');
+        return this.packageUpdates.update(signal);
+    }
     async restartDaemon(signal) { await this.runner().restartDaemon(signal); return true; }
     async discoverOpenCli(signal) {
         return discoverOpenCli(this.store.settings.opencliPath, signal);

package/lib/typert.js

@@ -14,6 +14,9 @@ export const TYPERT_MANIFEST = {
                     { kind: 'method', name: 'installOpenCli', signature: 'installOpenCli(signal: AbortSignal): Promise<OpenCliDiscovery>' },
                     { kind: 'method', name: 'installAdapter', signature: 'installAdapter(signal: AbortSignal): Promise<boolean>' },
                     { kind: 'method', name: 'restartDaemon', signature: 'restartDaemon(signal: AbortSignal): Promise<boolean>' },
+                    { kind: 'method', name: 'updateStatus', signature: 'updateStatus(signal: AbortSignal): Promise<PackageUpdateStatus>' },
+                    { kind: 'method', name: 'checkUpdate', signature: 'checkUpdate(signal: AbortSignal): Promise<PackageUpdateStatus>' },
+                    { kind: 'method', name: 'installUpdate', signature: 'installUpdate(signal: AbortSignal): Promise<PackageUpdateResult>' },
                     { kind: 'method', name: 'stats', signature: 'stats(): ProviderStats[]' },
                     { kind: 'method', name: 'syncStart', signature: 'syncStart(input: SyncStart): string' },
                     { kind: 'method', name: 'syncStatus', signature: 'syncStatus(input: JobInput): SyncStatus | undefined' },

package/lib/update.d.ts

@@ -0,0 +1,43 @@
+export declare const PACKAGE_NAME = "dsh-reference-anything";
+export declare const NPM_LATEST_URL = "https://registry.npmjs.org/dsh-reference-anything/latest";
+export interface PackageUpdateStatus {
+    currentVersion: string;
+    latestVersion: string;
+    updateAvailable: boolean;
+    checkedAt: number;
+    error?: string;
+}
+export interface PackageUpdateResult {
+    version: string;
+    restartRequired: boolean;
+}
+interface UpdateManagerOptions {
+    packageRoot?: string;
+    dshHome?: string;
+    fetchLatest?: (signal?: AbortSignal) => Promise<string>;
+    install?: (profileDir: string, version: string, signal?: AbortSignal) => Promise<void>;
+}
+/** One startup/manual-check cache and the confirmed profile-local updater. */
+export declare class PackageUpdateManager {
+    private readonly packageRoot;
+    private readonly dshHome?;
+    private readonly fetchLatest;
+    private readonly install;
+    private cached?;
+    private checking?;
+    constructor(options?: UpdateManagerOptions);
+    /** Return the startup result, waiting for it when it is still in flight. */
+    status(signal?: AbortSignal): Promise<PackageUpdateStatus>;
+    /** Force a registry read, while collapsing concurrent startup/manual clicks. */
+    check(signal?: AbortSignal): Promise<PackageUpdateStatus>;
+    /** Install only the exact version returned by a fresh registry check. */
+    update(signal?: AbortSignal): Promise<PackageUpdateResult>;
+    private runCheck;
+}
+export declare function fetchLatestVersion(signal?: AbortSignal): Promise<string>;
+export declare function readPackageVersion(packageRoot?: string): Promise<string>;
+/** Find the profile that owns this exact installed package, including pnpm links. */
+export declare function findOwningProfileDir(packageRoot?: string, configuredDshHome?: string): Promise<string>;
+export declare function installPackageVersion(profileDir: string, version: string, signal?: AbortSignal): Promise<void>;
+export declare function compareVersions(left: string, right: string): number;
+export {};

package/lib/update.js

@@ -0,0 +1,203 @@
+import { execFile as nodeExecFile } from 'node:child_process';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { access, readFile, readdir, realpath } from 'node:fs/promises';
+import { promisify } from 'node:util';
+const execFile = promisify(nodeExecFile);
+export const PACKAGE_NAME = 'dsh-reference-anything';
+export const NPM_LATEST_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const PACKAGE_ROOT = resolve(fileURLToPath(new URL('../', import.meta.url)));
+const UPDATE_TIMEOUT_MS = 5 * 60_000;
+const CHECK_TIMEOUT_MS = 10_000;
+/** One startup/manual-check cache and the confirmed profile-local updater. */
+export class PackageUpdateManager {
+    packageRoot;
+    dshHome;
+    fetchLatest;
+    install;
+    cached;
+    checking;
+    constructor(options = {}) {
+        this.packageRoot = resolve(options.packageRoot ?? PACKAGE_ROOT);
+        this.dshHome = options.dshHome;
+        this.fetchLatest = options.fetchLatest ?? fetchLatestVersion;
+        this.install = options.install ?? installPackageVersion;
+    }
+    /** Return the startup result, waiting for it when it is still in flight. */
+    status(signal) {
+        if (this.checking)
+            return this.checking;
+        if (this.cached)
+            return Promise.resolve(this.cached);
+        return this.check(signal);
+    }
+    /** Force a registry read, while collapsing concurrent startup/manual clicks. */
+    check(signal) {
+        if (this.checking)
+            return this.checking;
+        const request = this.runCheck(signal).finally(() => {
+            if (this.checking === request)
+                this.checking = undefined;
+        });
+        this.checking = request;
+        return request;
+    }
+    /** Install only the exact version returned by a fresh registry check. */
+    async update(signal) {
+        const status = await this.check(signal);
+        if (status.error)
+            throw new Error(status.error);
+        if (!status.updateAvailable)
+            return { version: status.currentVersion, restartRequired: false };
+        const profileDir = await findOwningProfileDir(this.packageRoot, this.dshHome);
+        await this.install(profileDir, status.latestVersion, signal);
+        this.cached = {
+            currentVersion: status.latestVersion,
+            latestVersion: status.latestVersion,
+            updateAvailable: false,
+            checkedAt: Date.now(),
+        };
+        return { version: status.latestVersion, restartRequired: true };
+    }
+    async runCheck(signal) {
+        const checkedAt = Date.now();
+        let currentVersion = '0.0.0';
+        try {
+            currentVersion = await readPackageVersion(this.packageRoot);
+            const latestVersion = await this.fetchLatest(signal);
+            const status = {
+                currentVersion,
+                latestVersion,
+                updateAvailable: compareVersions(latestVersion, currentVersion) > 0,
+                checkedAt,
+            };
+            this.cached = status;
+            return status;
+        }
+        catch (error) {
+            const status = {
+                currentVersion,
+                latestVersion: '',
+                updateAvailable: false,
+                checkedAt,
+                error: `Unable to check npm for updates: ${error instanceof Error ? error.message : String(error)}`,
+            };
+            this.cached = status;
+            return status;
+        }
+    }
+}
+export async function fetchLatestVersion(signal) {
+    const timeout = AbortSignal.timeout(CHECK_TIMEOUT_MS);
+    const response = await fetch(NPM_LATEST_URL, {
+        headers: { accept: 'application/vnd.npm.install-v1+json' },
+        signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+    });
+    if (!response.ok)
+        throw new Error(`npm registry returned HTTP ${String(response.status)}`);
+    const body = await response.json();
+    if (typeof body.version !== 'string' || !isVersion(body.version))
+        throw new Error('npm registry returned an invalid version');
+    return body.version;
+}
+export async function readPackageVersion(packageRoot = PACKAGE_ROOT) {
+    const manifest = await readJson(join(packageRoot, 'package.json'));
+    if (typeof manifest.version !== 'string' || !isVersion(manifest.version))
+        throw new Error('installed package has an invalid version');
+    return manifest.version;
+}
+/** Find the profile that owns this exact installed package, including pnpm links. */
+export async function findOwningProfileDir(packageRoot = PACKAGE_ROOT, configuredDshHome) {
+    const resolvedRoot = resolve(packageRoot);
+    for (let cursor = resolvedRoot; dirname(cursor) !== cursor; cursor = dirname(cursor)) {
+        if (await isOwningProfile(cursor, resolvedRoot))
+            return cursor;
+    }
+    const dshHome = resolve(configuredDshHome || process.env.DSH_HOME || join(homedir(), '.dsh'));
+    const profilesRoot = join(dshHome, 'profiles');
+    let entries = [];
+    try {
+        entries = await readdir(profilesRoot, { withFileTypes: true });
+    }
+    catch { /* handled below */ }
+    const matches = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const profileDir = join(profilesRoot, entry.name);
+        if (await isOwningProfile(profileDir, resolvedRoot))
+            matches.push(profileDir);
+    }
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length > 1)
+        throw new Error('more than one DSH profile points to this installation; update it from the command line');
+    throw new Error('the owning DSH profile could not be identified; update it with dsh plugin --profile <name> add dsh-reference-anything@latest');
+}
+export async function installPackageVersion(profileDir, version, signal) {
+    if (!isVersion(version))
+        throw new Error('refusing to install an invalid package version');
+    try {
+        await execFile('pnpm', ['add', `${PACKAGE_NAME}@${version}`], {
+            cwd: profileDir,
+            encoding: 'utf8',
+            timeout: UPDATE_TIMEOUT_MS,
+            maxBuffer: 8 * 1024 * 1024,
+            windowsHide: true,
+            shell: process.platform === 'win32',
+            signal,
+        });
+    }
+    catch (error) {
+        const detail = error;
+        const output = String(detail.stderr || detail.stdout || '').trim().slice(0, 2_000);
+        throw new Error(output || 'pnpm could not update the DSH profile package', { cause: error });
+    }
+}
+export function compareVersions(left, right) {
+    if (!isVersion(left) || !isVersion(right))
+        throw new Error('cannot compare an invalid package version');
+    const [leftCore, leftPre] = left.split('-', 2);
+    const [rightCore, rightPre] = right.split('-', 2);
+    const a = leftCore.split('.').map(Number);
+    const b = rightCore.split('.').map(Number);
+    for (let index = 0; index < 3; index++) {
+        if (a[index] !== b[index])
+            return (a[index] ?? 0) > (b[index] ?? 0) ? 1 : -1;
+    }
+    if (leftPre === rightPre)
+        return 0;
+    if (leftPre === undefined)
+        return 1;
+    if (rightPre === undefined)
+        return -1;
+    return leftPre.localeCompare(rightPre, 'en', { numeric: true });
+}
+function isVersion(value) {
+    return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z]+(?:[.-][0-9A-Za-z]+)*)?$/.test(value);
+}
+async function isOwningProfile(profileDir, packageRoot) {
+    let manifest;
+    try {
+        manifest = await readJson(join(profileDir, 'package.json'));
+    }
+    catch {
+        return false;
+    }
+    const dsh = manifest.dsh;
+    const dependencies = manifest.dependencies;
+    if (!dsh?.profile || typeof dependencies?.[PACKAGE_NAME] !== 'string')
+        return false;
+    const installedRoot = join(profileDir, 'node_modules', PACKAGE_NAME);
+    try {
+        await access(join(installedRoot, 'package.json'));
+        return await realpath(installedRoot) === await realpath(packageRoot);
+    }
+    catch {
+        return false;
+    }
+}
+async function readJson(path) {
+    return JSON.parse(await readFile(path, 'utf8'));
+}

package/opencli-plugin/common.js

@@ -49,23 +49,6 @@ function assertResult(result, domain, operation) {
   return result.rows
 }
 
-/**
- * Release only the one-shot task tab. Browser Bridge deliberately keeps its
- * empty adapter container alive so the next sync can reuse it; if the user
- * closes that container, Browser Bridge recreates it on demand.
- */
-async function inTemporaryTab(page, task) {
-  try {
-    return await task()
-  } finally {
-    try {
-      await page.closeTab?.()
-    } catch {
-      // Preserve the provider result/error if the browser closed first.
-    }
-  }
-}
-
 export function registerProvider(config) {
   const browserSession = SYNC_BROWSER_SESSION
 
@@ -81,15 +64,15 @@ export function registerProvider(config) {
     navigateBefore: false,
     args: [],
     columns: ['identity'],
-    func: async (page) => inTemporaryTab(page, async () => {
-      await page.goto(config.home, { settleMs: 500 })
-      const result = await evaluate(page, config.whoamiScript, {}, `${config.site} whoami`)
-      if (result?.code === 'AUTH') throw new AuthRequiredError(config.domain)
+    func: async (page) => {
+      await page.goto(config.home, { settleMs: 500 })
+      const result = await evaluate(page, config.whoamiScript, {}, `${config.site} whoami`)
+      if (result?.code === 'AUTH') throw new AuthRequiredError(config.domain)
       if (result?.ok !== true || typeof result.identity !== 'string' || !result.identity) {
         throw new CommandExecutionError(`${config.site} whoami: ${result?.message || 'stable account identity unavailable'}`)
-      }
-      return [{ identity: result.identity }]
-    }),
+      }
+      return [{ identity: result.identity }]
+    },
   })
 
   cli({
@@ -107,7 +90,7 @@ export function registerProvider(config) {
       help: 'ISO 8601 instant; stop paging once the listing predates it. Honoured only while the provider pages newest-first',
     }, { name: 'accountScope', help: 'Previously observed hashed account scope; mismatch forces a full listing' }],
     columns: SYNC_INDEX_COLUMNS,
-    func: async (page, kwargs) => inTemporaryTab(page, async () => {
+    func: async (page, kwargs) => {
       const since = String(kwargs.since || '').trim()
       if (since && Number.isNaN(Date.parse(since))) throw new ArgumentError('since must be an ISO 8601 instant')
       await page.goto(config.home, { settleMs: 1200 })
@@ -127,7 +110,7 @@ export function registerProvider(config) {
         { kind: 'identity', identity: identity.identity, sinceApplied: effectiveSince },
         ...rows.map(row => ({ kind: 'conversation', identity: '', sinceApplied: '', ...row })),
       ]
-    }),
+    },
   })
 
   cli({
@@ -145,17 +128,17 @@ export function registerProvider(config) {
       help: 'ISO 8601 instant; stop paging once the listing predates it. Honoured only while the provider pages newest-first',
     }],
     columns: HISTORY_COLUMNS,
-    func: async (page, kwargs) => inTemporaryTab(page, async () => {
-      const since = String(kwargs.since || '').trim()
+    func: async (page, kwargs) => {
+      const since = String(kwargs.since || '').trim()
       if (since && Number.isNaN(Date.parse(since))) throw new ArgumentError('since must be an ISO 8601 instant')
       await page.goto(config.home, { settleMs: 1200 })
       const rows = assertResult(
         await evaluate(page, config.historyScript, { since }, `${config.site} history-all`),
         config.domain,
         `${config.site} history-all`,
-      )
+      )
       return rows
-    }),
+    },
   })
 
   cli({
@@ -173,7 +156,7 @@ export function registerProvider(config) {
       { name: 'accountScope', help: 'Expected hashed account scope; mismatch refuses the read' },
     ],
     columns: DETAIL_COLUMNS,
-    func: async (page, kwargs) => inTemporaryTab(page, async () => {
+    func: async (page, kwargs) => {
       const id = String(kwargs.id || '').trim()
       if (!id) throw new ArgumentError('id must be a non-empty conversation id')
       await page.goto(config.home, { settleMs: 600 })
@@ -194,10 +177,10 @@ export function registerProvider(config) {
         await page.goto(config.conversationUrl(id), { settleMs: 1800 })
         result = await evaluate(page, config.fallbackScript, { id }, `${config.site} detail fallback`)
       }
-      const rows = assertResult(result, config.domain, `${config.site} detail`)
-      if (rows.length === 0) throw new EmptyResultError(`${config.site} detail`, `No messages found for ${id}`)
-      return rows
-    }),
+      const rows = assertResult(result, config.domain, `${config.site} detail`)
+      if (rows.length === 0) throw new EmptyResultError(`${config.site} detail`, `No messages found for ${id}`)
+      return rows
+    },
   })
 
   cli({
@@ -216,8 +199,8 @@ export function registerProvider(config) {
       { name: 'maxBytes', type: 'int', default: 26214400, help: 'Maximum decoded bytes' },
     ],
     columns: ['attachmentId', 'name', 'mimeType', 'size', 'status', 'localPath'],
-    func: async (page, kwargs) => inTemporaryTab(page, async () => {
-      const locator = String(kwargs.locator || '').trim()
+    func: async (page, kwargs) => {
+      const locator = String(kwargs.locator || '').trim()
       const output = resolve(String(kwargs.output || ''))
       const maxBytes = Number(kwargs.maxBytes ?? 26_214_400)
       if (!locator) throw new ArgumentError('locator must not be empty')
@@ -243,16 +226,21 @@ export function registerProvider(config) {
         name: result.name || output.split(/[\\/]/).pop() || 'attachment',
         mimeType: result.mimeType || 'application/octet-stream',
         size: bytes.byteLength,
-        status: 'available',
-        localPath: output,
-      }]
-    }),
+        status: 'available',
+        localPath: output,
+      }]
+    },
   })
 }
 
-/** Browser Bridge lifecycle contract shared by every web-chat sync command. */
+/**
+ * Keep one stable, background Browser Bridge session per provider site.
+ * OpenCLI maps persistent sessions to `site:<config.site>` and keeps their tab
+ * lease after both successful and failed commands, so later sync work reuses
+ * the same tab. If the user closes it manually, OpenCLI recreates it on demand.
+ */
 export const SYNC_BROWSER_SESSION = Object.freeze({
-  siteSession: 'ephemeral',
+  siteSession: 'persistent',
   defaultWindowMode: 'background',
 })
 

package/opencli-plugin/opencli-plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-chat-history",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "opencli": ">=1.8.6",
   "description": "Full-history read adapters used by dsh-reference-anything"
 }

package/opencli-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencli-plugin-dsh-chat-history",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "peerDependencies": {
     "@jackwener/opencli": ">=1.8.6"