dsh-reference-anything 0.2.0

package/lib/uri-codec.js

@@ -0,0 +1,39 @@
+export const REFERENCE_SCHEME = 'dsh-ref:';
+const PAYLOAD_PATTERN = /^[A-Za-z0-9_-]+$/u;
+export function encodeReferenceUri(ref) {
+    const payload = encodeBase64Url(JSON.stringify({ source: ref.source, id: ref.id }));
+    return `${REFERENCE_SCHEME}${payload}`;
+}
+export function decodeReferenceUriUnchecked(uri) {
+    if (!uri.startsWith(REFERENCE_SCHEME))
+        throw new TypeError('wrong reference scheme');
+    const payload = uri.slice(REFERENCE_SCHEME.length);
+    if (!PAYLOAD_PATTERN.test(payload))
+        throw new TypeError('invalid base64url payload');
+    const parsed = JSON.parse(decodeBase64Url(payload));
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new TypeError('decoded reference is not an object');
+    }
+    const { source, id } = parsed;
+    if (typeof source !== 'string' || typeof id !== 'string') {
+        throw new TypeError('decoded reference lacks string source and id');
+    }
+    const ref = { source, id };
+    if (encodeReferenceUri(ref) !== uri)
+        throw new TypeError('URI is not canonical');
+    return ref;
+}
+function encodeBase64Url(value) {
+    const bytes = new TextEncoder().encode(value);
+    let binary = '';
+    for (let offset = 0; offset < bytes.length; offset += 0x8000) {
+        binary += String.fromCharCode(...bytes.subarray(offset, Math.min(bytes.length, offset + 0x8000)));
+    }
+    return btoa(binary).replace(/\+/gu, '-').replace(/\//gu, '_').replace(/=+$/gu, '');
+}
+function decodeBase64Url(value) {
+    const base64 = value.replace(/-/gu, '+').replace(/_/gu, '/') + '='.repeat((4 - value.length % 4) % 4);
+    const binary = atob(base64);
+    const bytes = Uint8Array.from(binary, character => character.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+}

package/lib/uri.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Canonical `dsh-ref:` URI and the inline mention that carries it.
+ *
+ * A reference is two opaque strings, either of which may contain any character
+ * a JavaScript string can hold. JSON-encoding the pair before base64url means
+ * quotes, slashes, backslashes, newlines, and astral characters all survive
+ * without a delimiter the payload could itself spell.
+ *
+ * @module dsh-reference-anything/uri
+ */
+import type { ReferenceInput, ReferenceRef } from './types.ts';
+import { encodeReferenceUri, REFERENCE_SCHEME } from './uri-codec.ts';
+export { encodeReferenceUri, REFERENCE_SCHEME };
+/**
+ * Decode one canonical reference URI.
+ *
+ * Re-encodes the decoded value and compares: base64url has multiple spellings
+ * of the same bytes, and JSON has multiple spellings of the same object, so
+ * without this check two different URIs could name one reference and a
+ * consumer deduplicating by string would keep both.
+ * @param uri - complete URI, including the scheme.
+ * @returns the decoded reference.
+ */
+export declare function decodeReferenceUri(uri: string): ReferenceRef;
+/**
+ * Render a host-neutral Markdown mention carrying the canonical URI.
+ * @param ref - the reference to name.
+ * @param label - display text; falls back to the item id when empty.
+ * @returns an escaped `@[label](uri)` mention.
+ */
+export declare function formatReferenceMention(ref: ReferenceRef, label?: string): string;
+/** Readable text with mentions replaced, plus the references they named. */
+export interface ParsedReferenceText {
+    /** The original text with every mention replaced by a readable `@label`. */
+    readonly text: string;
+    /** References in first-appearance order, before deduplication. */
+    readonly references: readonly ReferenceInput[];
+}
+/**
+ * Extract Markdown mentions and bare canonical URIs from one text value.
+ *
+ * An explicit `@[label](dsh-ref:…)` mention is a claim that this is a
+ * reference, so a malformed URI there is an error rather than prose. Bare text
+ * is only treated as a reference when it carries a base64url-shaped payload;
+ * a bare `dsh-ref:` with nothing after it stays ordinary discussion text, so
+ * writing *about* the scheme does not accidentally reference anything.
+ * @param text - the user's text.
+ * @returns readable text and the references it named, in order.
+ */
+export declare function parseReferenceText(text: string): ParsedReferenceText;
+/**
+ * Whether text could possibly contain a reference.
+ *
+ * The mention expander runs on every step of every turn, so the overwhelmingly
+ * common answer must cost one substring scan rather than a regex pass.
+ * @param text - the text to screen.
+ * @returns whether a full parse is worth running.
+ */
+export declare function mayContainReference(text: string): boolean;

package/lib/uri.js

@@ -0,0 +1,86 @@
+/**
+ * Canonical `dsh-ref:` URI and the inline mention that carries it.
+ *
+ * A reference is two opaque strings, either of which may contain any character
+ * a JavaScript string can hold. JSON-encoding the pair before base64url means
+ * quotes, slashes, backslashes, newlines, and astral characters all survive
+ * without a delimiter the payload could itself spell.
+ *
+ * @module dsh-reference-anything/uri
+ */
+import { ReferenceAnythingError } from "./errors.js";
+import { decodeReferenceUriUnchecked, encodeReferenceUri, REFERENCE_SCHEME } from "./uri-codec.js";
+export { encodeReferenceUri, REFERENCE_SCHEME };
+/**
+ * Decode one canonical reference URI.
+ *
+ * Re-encodes the decoded value and compares: base64url has multiple spellings
+ * of the same bytes, and JSON has multiple spellings of the same object, so
+ * without this check two different URIs could name one reference and a
+ * consumer deduplicating by string would keep both.
+ * @param uri - complete URI, including the scheme.
+ * @returns the decoded reference.
+ */
+export function decodeReferenceUri(uri) {
+    try {
+        return decodeReferenceUriUnchecked(uri);
+    }
+    catch (error) {
+        throw invalidUri(uri, error);
+    }
+}
+/**
+ * Render a host-neutral Markdown mention carrying the canonical URI.
+ * @param ref - the reference to name.
+ * @param label - display text; falls back to the item id when empty.
+ * @returns an escaped `@[label](uri)` mention.
+ */
+export function formatReferenceMention(ref, label) {
+    const shown = label === undefined || label === '' ? ref.id : label;
+    return `@[${escapeLabel(shown)}](${encodeReferenceUri(ref)})`;
+}
+/**
+ * Extract Markdown mentions and bare canonical URIs from one text value.
+ *
+ * An explicit `@[label](dsh-ref:…)` mention is a claim that this is a
+ * reference, so a malformed URI there is an error rather than prose. Bare text
+ * is only treated as a reference when it carries a base64url-shaped payload;
+ * a bare `dsh-ref:` with nothing after it stays ordinary discussion text, so
+ * writing *about* the scheme does not accidentally reference anything.
+ * @param text - the user's text.
+ * @returns readable text and the references it named, in order.
+ */
+export function parseReferenceText(text) {
+    const references = [];
+    const pattern = /@\[((?:\\.|[^\\\]])*)\]\((dsh-ref:[^\s)]*)\)|(dsh-ref:[A-Za-z0-9_-]+)/gu;
+    const rendered = text.replace(pattern, (_match, rawLabel, markdownUri, bareUri) => {
+        const uri = markdownUri ?? bareUri;
+        if (uri === undefined)
+            throw invalidUri(String(_match));
+        const ref = decodeReferenceUri(uri);
+        const label = rawLabel === undefined ? ref.id : unescapeLabel(rawLabel);
+        references.push({ ref, label });
+        return `@${label}`;
+    });
+    return { text: rendered, references };
+}
+/**
+ * Whether text could possibly contain a reference.
+ *
+ * The mention expander runs on every step of every turn, so the overwhelmingly
+ * common answer must cost one substring scan rather than a regex pass.
+ * @param text - the text to screen.
+ * @returns whether a full parse is worth running.
+ */
+export function mayContainReference(text) {
+    return text.includes(REFERENCE_SCHEME);
+}
+function escapeLabel(label) {
+    return label.replace(/[\\\]]/gu, match => `\\${match}`);
+}
+function unescapeLabel(label) {
+    return label.replace(/\\(.)/gu, '$1');
+}
+function invalidUri(uri, cause) {
+    return new ReferenceAnythingError(`invalid reference URI ${JSON.stringify(uri)}`, 'REFERENCE_INVALID_URI', cause === undefined ? undefined : { cause });
+}

package/lib/web.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "reference-anything-web";
+export declare const inject: string[];
+export declare function apply(ctx: Context): void;

package/lib/web.js

@@ -0,0 +1,11 @@
+import { ReferenceAnythingRemote } from "./host.js";
+import { TYPERT_MANIFEST } from "./typert.js";
+export const name = 'reference-anything-web';
+export const inject = ['typert', 'referenceChatHistory', 'sessionReferenceResolver'];
+export function apply(ctx) {
+    new ReferenceAnythingRemote(ctx);
+    ctx.effect(() => {
+        const dispose = ctx.typert.register(TYPERT_MANIFEST);
+        return () => { void dispose(); };
+    }, 'reference-anything-web.typert');
+}

package/lib/window.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Taking one window out of a conversation a source already holds in full.
+ *
+ * Sources that can read the whole conversation cheaply — a file, an export, an
+ * in-page payload — share this instead of each re-deriving the index
+ * arithmetic. A source that pages upstream computes its own slice and does not
+ * use this.
+ *
+ * @module dsh-reference-anything/window
+ */
+import type { ConversationItem, ReferenceSlice, ReferenceWindow } from './types.ts';
+/**
+ * Select the requested turns and say where they sit.
+ *
+ * `before` is clamped rather than rejected. A model reading backwards knows
+ * the index it last saw but not always the total, so asking for turns before a
+ * number past the end is an ordinary first request, not an error; the returned
+ * `startIndex` and `hasOlder` tell it where it actually landed.
+ * @param items - the complete conversation, oldest first.
+ * @param window - the requested turns.
+ * @returns the selected turns and their position.
+ */
+export declare function sliceTurns(items: readonly ConversationItem[], window: ReferenceWindow): ReferenceSlice;

package/lib/window.js

@@ -0,0 +1,35 @@
+/**
+ * Taking one window out of a conversation a source already holds in full.
+ *
+ * Sources that can read the whole conversation cheaply — a file, an export, an
+ * in-page payload — share this instead of each re-deriving the index
+ * arithmetic. A source that pages upstream computes its own slice and does not
+ * use this.
+ *
+ * @module dsh-reference-anything/window
+ */
+/**
+ * Select the requested turns and say where they sit.
+ *
+ * `before` is clamped rather than rejected. A model reading backwards knows
+ * the index it last saw but not always the total, so asking for turns before a
+ * number past the end is an ordinary first request, not an error; the returned
+ * `startIndex` and `hasOlder` tell it where it actually landed.
+ * @param items - the complete conversation, oldest first.
+ * @param window - the requested turns.
+ * @returns the selected turns and their position.
+ */
+export function sliceTurns(items, window) {
+    const totalTurns = items.length;
+    const end = window.before === undefined
+        ? totalTurns
+        : Math.max(0, Math.min(Math.trunc(window.before), totalTurns));
+    const start = Math.max(0, end - Math.max(0, Math.trunc(window.limit)));
+    return {
+        kind: 'conversation',
+        items: items.slice(start, end),
+        startIndex: start,
+        totalTurns,
+        hasOlder: start > 0,
+    };
+}

package/lib/wire.d.ts

@@ -0,0 +1,117 @@
+/** JSON-compatible schema shared by the Host Remote and browser client. */
+import { z } from 'zod';
+export declare const providerSchema: z.ZodEnum<{
+    chatgpt: "chatgpt";
+    claude: "claude";
+    gemini: "gemini";
+    deepseek: "deepseek";
+    grok: "grok";
+    kimi: "kimi";
+}>;
+export type ChatProvider = z.infer<typeof providerSchema>;
+export declare const ALL_PROVIDERS: readonly ChatProvider[];
+export declare const pickerSourceSchema: z.ZodEnum<{
+    commands: "commands";
+    skills: "skills";
+    files: "files";
+    sessions: "sessions";
+    conversations: "conversations";
+}>;
+export type PickerSource = z.infer<typeof pickerSourceSchema>;
+declare const pickerSourceSettingsSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    order: z.ZodNumber;
+    limit: z.ZodNumber;
+}, z.core.$strip>;
+export type PickerSourceSettings = z.infer<typeof pickerSourceSettingsSchema>;
+export declare const pickerSettingsSchema: z.ZodObject<{
+    commands: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        order: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+    skills: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        order: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+    files: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        order: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+    sessions: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        order: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+    conversations: z.ZodObject<{
+        enabled: z.ZodBoolean;
+        order: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PickerSettings = z.infer<typeof pickerSettingsSchema>;
+export declare const inputRenderModeSchema: z.ZodEnum<{
+    pill: "pill";
+    "raw-text": "raw-text";
+}>;
+export type InputRenderMode = z.infer<typeof inputRenderModeSchema>;
+/** Defaults used before the user saves the General section. */
+export declare function defaultPickerSettings(): PickerSettings;
+/** Picker settings have a fixed schema, so explicit comparison is cheap and stable. */
+export declare function samePickerSettings(left: PickerSettings, right: PickerSettings): boolean;
+export declare const settingsRecordSchema: z.ZodObject<{
+    opencliPath: z.ZodString;
+    profile: z.ZodString;
+    detailConcurrency: z.ZodNumber;
+    autoSync: z.ZodDefault<z.ZodBoolean>;
+    syncOnStartup: z.ZodDefault<z.ZodBoolean>;
+    autoSyncMinutes: z.ZodDefault<z.ZodNumber>;
+    historyMode: z.ZodDefault<z.ZodEnum<{
+        "metadata-only": "metadata-only";
+        "offline-mirror": "offline-mirror";
+    }>>;
+    enabledProviders: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>>>;
+    maxReadTurns: z.ZodDefault<z.ZodNumber>;
+    inputRenderMode: z.ZodDefault<z.ZodEnum<{
+        pill: "pill";
+        "raw-text": "raw-text";
+    }>>;
+    picker: z.ZodOptional<z.ZodObject<{
+        commands: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            order: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$strip>;
+        skills: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            order: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$strip>;
+        files: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            order: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$strip>;
+        sessions: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            order: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$strip>;
+        conversations: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            order: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SettingsRecord = z.infer<typeof settingsRecordSchema>;
+export {};

package/lib/wire.js

@@ -0,0 +1,49 @@
+/** JSON-compatible schema shared by the Host Remote and browser client. */
+import { z } from 'zod';
+export const providerSchema = z.enum(['chatgpt', 'claude', 'gemini', 'deepseek', 'grok', 'kimi']);
+export const ALL_PROVIDERS = providerSchema.options;
+export const pickerSourceSchema = z.enum(['commands', 'skills', 'files', 'sessions', 'conversations']);
+const pickerSourceSettingsSchema = z.object({
+    enabled: z.boolean(),
+    order: z.number().int().min(0).max(100),
+    limit: z.number().int().min(1).max(50),
+});
+export const pickerSettingsSchema = z.object({
+    commands: pickerSourceSettingsSchema,
+    skills: pickerSourceSettingsSchema,
+    files: pickerSourceSettingsSchema,
+    sessions: pickerSourceSettingsSchema,
+    conversations: pickerSourceSettingsSchema,
+});
+export const inputRenderModeSchema = z.enum(['pill', 'raw-text']);
+/** Defaults used before the user saves the General section. */
+export function defaultPickerSettings() {
+    return {
+        commands: { enabled: true, order: 0, limit: 6 },
+        skills: { enabled: true, order: 5, limit: 6 },
+        files: { enabled: true, order: 10, limit: 6 },
+        sessions: { enabled: true, order: 20, limit: 6 },
+        conversations: { enabled: true, order: 30, limit: 6 },
+    };
+}
+/** Picker settings have a fixed schema, so explicit comparison is cheap and stable. */
+export function samePickerSettings(left, right) {
+    return Object.keys(left).every(key => left[key].enabled === right[key].enabled &&
+        left[key].order === right[key].order &&
+        left[key].limit === right[key].limit);
+}
+export const settingsRecordSchema = z.object({
+    opencliPath: z.string(),
+    profile: z.string(),
+    detailConcurrency: z.number().int().min(1).max(8),
+    autoSync: z.boolean().default(false),
+    syncOnStartup: z.boolean().default(false),
+    autoSyncMinutes: z.number().int().min(15).max(1440).default(60),
+    historyMode: z.enum(['metadata-only', 'offline-mirror']).default('metadata-only'),
+    enabledProviders: z.array(providerSchema).default([...ALL_PROVIDERS]),
+    maxReadTurns: z.number().int().min(1).max(100).default(10),
+    inputRenderMode: inputRenderModeSchema.default('pill'),
+    // Optional keeps existing on-disk settings forward-compatible. The client
+    // uses defaultPickerSettings() until the user saves the General section.
+    picker: pickerSettingsSchema.optional(),
+});

package/lib/workspace.d.ts

@@ -0,0 +1,18 @@
+import type { Agent } from '@deepseek-ai/dsh-agent';
+export declare const WORKSPACE_REFERENCE_SCHEME = "dsh-file:";
+export interface WorkspaceEntry {
+    path: string;
+    kind: 'file' | 'directory';
+}
+export interface WorkspaceReference {
+    path: string;
+    label: string;
+}
+export declare function indexWorkspace(agent: Agent, signal: AbortSignal, maxFiles?: number): Promise<WorkspaceEntry[]>;
+export declare function encodeWorkspaceReferenceUri(path: string): string;
+export declare function formatWorkspaceMention(reference: WorkspaceReference): string;
+export declare function parseWorkspaceReferenceText(text: string): {
+    text: string;
+    references: WorkspaceReference[];
+};
+export declare function renderWorkspaceReferences(agent: Agent, references: readonly WorkspaceReference[]): Promise<string>;

package/lib/workspace.js

@@ -0,0 +1,81 @@
+import { lstat, readdir } from 'node:fs/promises';
+import { basename, isAbsolute, relative, resolve, sep } from 'node:path';
+export const WORKSPACE_REFERENCE_SCHEME = 'dsh-file:';
+const IGNORED = new Set(['.git', '.hg', '.svn', 'node_modules', 'dist', 'build', 'coverage', '.next', '.cache', '.idea', '.vscode', '__pycache__']);
+const IGNORED_FILES = new Set(['desktop.ini', 'Thumbs.db', '.DS_Store']);
+export async function indexWorkspace(agent, signal, maxFiles = 5000) {
+    const root = agent.session.header.cwd;
+    if (!root || !isAbsolute(root))
+        return [];
+    const output = [];
+    const queue = ['.'];
+    while (queue.length > 0 && output.length < maxFiles) {
+        signal.throwIfAborted();
+        const current = queue.shift();
+        let entries;
+        try {
+            entries = await readdir(resolve(root, current), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            if (output.length >= maxFiles)
+                break;
+            if (entry.isSymbolicLink() || IGNORED_FILES.has(entry.name))
+                continue;
+            const path = current === '.' ? entry.name : `${current}/${entry.name}`;
+            if (entry.isDirectory()) {
+                if (IGNORED.has(entry.name))
+                    continue;
+                output.push({ path, kind: 'directory' });
+                queue.push(path);
+            }
+            else if (entry.isFile())
+                output.push({ path, kind: 'file' });
+        }
+    }
+    return output;
+}
+export function encodeWorkspaceReferenceUri(path) {
+    return `${WORKSPACE_REFERENCE_SCHEME}${Buffer.from(JSON.stringify(path), 'utf8').toString('base64url')}`;
+}
+export function formatWorkspaceMention(reference) {
+    return `@[${reference.label.replace(/[\\\]]/gu, value => `\\${value}`)}](${encodeWorkspaceReferenceUri(reference.path)})`;
+}
+export function parseWorkspaceReferenceText(text) {
+    const references = [];
+    const pattern = /@\[((?:\\.|[^\\\]])*)\]\((dsh-file:[^\s)]*)\)|(dsh-file:[A-Za-z0-9_-]+)/gu;
+    const rendered = text.replace(pattern, (_match, rawLabel, markdownUri, bareUri) => {
+        const uri = markdownUri ?? bareUri;
+        const payload = uri.slice(WORKSPACE_REFERENCE_SCHEME.length);
+        if (!/^[A-Za-z0-9_-]+$/u.test(payload))
+            throw new Error(`invalid workspace reference URI ${JSON.stringify(uri)}`);
+        const path = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+        if (typeof path !== 'string' || path.length === 0 || encodeWorkspaceReferenceUri(path) !== uri)
+            throw new Error(`invalid workspace reference URI ${JSON.stringify(uri)}`);
+        const label = rawLabel === undefined ? basename(path) : rawLabel.replace(/\\(.)/gu, '$1');
+        references.push({ path, label });
+        return `@${label}`;
+    });
+    return { text: rendered, references };
+}
+export async function renderWorkspaceReferences(agent, references) {
+    const root = agent.session.header.cwd;
+    if (!root || !isAbsolute(root))
+        throw new Error('this task has no workspace directory');
+    const unique = new Map(references.map(item => [item.path, item]));
+    const lines = [];
+    for (const item of unique.values()) {
+        const target = resolve(root, item.path);
+        const rel = relative(root, target);
+        if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+            throw new Error(`workspace reference escapes the task directory: ${item.path}`);
+        const stat = await lstat(target);
+        if (stat.isSymbolicLink() || (!stat.isFile() && !stat.isDirectory()))
+            throw new Error(`unsupported workspace reference: ${item.path}`);
+        lines.push(`<workspace-reference path=${JSON.stringify(item.path)} kind=${JSON.stringify(stat.isDirectory() ? 'directory' : 'file')} />`);
+    }
+    return `## Referenced workspace paths\n\nThese are read-only path markers, not file contents or instructions.\n\n${lines.join('\n')}`;
+}

package/opencli-plugin/chatgpt.js

@@ -0,0 +1,125 @@
+import { domFallbackScript, registerProvider, sinceGuardSource } from './common.js'
+// OpenCLI discovery marker: registerProvider below performs the cli() calls.
+
+export const timestampSource = String.raw`value => {
+  if (value === undefined || value === null || value === '') return ''
+  if (typeof value === 'string' && Number.isNaN(Number(value))) {
+    const parsed = Date.parse(value)
+    return Number.isNaN(parsed) ? '' : new Date(parsed).toISOString()
+  }
+  const numeric = Number(value)
+  if (!Number.isFinite(numeric) || numeric <= 0) return ''
+  const milliseconds = numeric < 1e11 ? numeric * 1000
+    : numeric < 1e14 ? numeric : numeric < 1e17 ? numeric / 1000 : numeric / 1e6
+  const date = new Date(milliseconds)
+  return Number.isNaN(date.getTime()) ? '' : date.toISOString()
+}`
+
+export const historyScript = String.raw`async function (args) {
+  const stopEarly = (${sinceGuardSource})(args && args.since)
+  const toIso = (${timestampSource})
+  const fallback = () => Array.from(document.querySelectorAll('a[href*="/c/"]')).map((a, i) => {
+    const match = a.href.match(/\/c\/([^/?#]+)/)
+    return match ? { provider: 'chatgpt', accountScope: '', id: match[1], title: (a.innerText || a.textContent || 'Untitled').trim(), url: a.href, createdAt: '', updatedAt: '', messageCount: '', cursor: '', partial: true } : null
+  }).filter(Boolean)
+  try {
+    const session = await fetch('/api/auth/session', { credentials: 'include' })
+    if (session.status === 401 || session.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+    const sessionData = session.ok ? await session.json() : {}
+    const token = sessionData.accessToken || sessionData.access_token || ''
+    const headers = { Accept: 'application/json', ...(token ? { Authorization: 'Bearer ' + token } : {}) }
+    const rows = []
+    for (let offset = 0, page = 0; page < 200; page++, offset += 100) {
+      const response = await fetch('/backend-api/conversations?offset=' + offset + '&limit=100&order=updated', { credentials: 'include', headers })
+      if (response.status === 401 || response.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+      if (response.status === 429) return JSON.stringify({ ok: false, code: 'RATE_LIMIT' })
+      if (!response.ok) throw new Error('history HTTP ' + response.status)
+      const data = await response.json()
+      const items = data.items || data.conversations || []
+      const pageStart = rows.length
+      for (const item of items) rows.push({
+        provider: 'chatgpt', accountScope: '', id: String(item.id), title: item.title || 'Untitled Conversation',
+        url: location.origin + '/c/' + item.id,
+        createdAt: toIso(item.create_time),
+        updatedAt: toIso(item.update_time),
+        messageCount: item.message_count || item.messageCount || '', cursor: '', partial: false,
+      })
+      if (items.length < 100) return JSON.stringify({ ok: true, rows })
+      if (stopEarly(rows.slice(pageStart))) return JSON.stringify({ ok: true, rows })
+    }
+    return JSON.stringify({ ok: false, message: 'pagination exceeded 200 pages' })
+  } catch (error) {
+    const rows = fallback()
+    return JSON.stringify({ ok: rows.length > 0, rows, message: rows.length ? '' : String(error && error.message || error) })
+  }
+}`
+
+const detailScript = String.raw`async function (args) {
+  const attachment = (part, index) => {
+    if (!part || typeof part !== 'object') return null
+    const pointer = part.asset_pointer || part.file_id || part.id || ''
+    const rawUrl = part.url || part.download_url || ''
+    let locator = ''
+    try { if (rawUrl) { const u = new URL(rawUrl, location.origin); if (u.origin === location.origin && u.pathname !== '/') locator = u.pathname + u.search } } catch {}
+    if (!pointer && !locator) return null
+    return { attachmentId: String(pointer || locator || index), kind: part.content_type === 'image_asset_pointer' || /^image\//.test(part.mime_type || '') ? 'image' : 'file', name: part.name || part.file_name || '', mimeType: part.mime_type || '', size: part.size || null, locator, status: locator ? 'available' : 'unavailable' }
+  }
+  const partsOf = (msg) => {
+    const parts = Array.isArray(msg && msg.content && msg.content.parts) ? msg.content.parts : []
+    const text = parts.filter(p => typeof p === 'string').join('\n').trim()
+    const attachments = parts.map(attachment).filter(Boolean)
+    return { text, attachments }
+  }
+  try {
+    const session = await fetch('/api/auth/session', { credentials: 'include' })
+    const sessionData = session.ok ? await session.json() : {}
+    const token = sessionData.accessToken || sessionData.access_token || ''
+    const response = await fetch('/backend-api/conversation/' + encodeURIComponent(args.id), { credentials: 'include', headers: { Accept: 'application/json', ...(token ? { Authorization: 'Bearer ' + token } : {}) } })
+    if (response.status === 401 || response.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+    if (response.status === 429) return JSON.stringify({ ok: false, code: 'RATE_LIMIT' })
+    if (!response.ok) return JSON.stringify({ ok: false, message: 'detail HTTP ' + response.status })
+    const data = await response.json()
+    const mapping = data.mapping && typeof data.mapping === 'object' ? data.mapping : {}
+    const active = new Set()
+    let cursor = data.current_node
+    while (cursor && mapping[cursor] && !active.has(cursor)) { active.add(cursor); cursor = mapping[cursor].parent }
+    const rows = []
+    for (const [nodeId, node] of Object.entries(mapping)) {
+      const msg = node && node.message
+      const role = msg && msg.author && msg.author.role
+      if (role !== 'user' && role !== 'assistant') continue
+      const projected = partsOf(msg)
+      if (!projected.text && projected.attachments.length === 0) continue
+      rows.push({
+        conversationId: args.id, ordinal: 0, messageId: msg.id || nodeId,
+        parentId: node.parent || '', branchId: nodeId, activeBranch: active.has(nodeId),
+        role, text: projected.text,
+        createdAt: msg.create_time ? new Date(msg.create_time * 1000).toISOString() : '',
+        attachmentsJson: JSON.stringify(projected.attachments), partial: false,
+      })
+    }
+    const ordered = []
+    let nodeId = data.current_node
+    while (nodeId && mapping[nodeId]) { ordered.unshift(nodeId); nodeId = mapping[nodeId].parent }
+    const position = new Map(ordered.map((id, index) => [id, index]))
+    rows.sort((a, b) => (position.get(a.branchId) ?? 100000) - (position.get(b.branchId) ?? 100000))
+    rows.forEach((row, index) => { row.ordinal = index })
+    return JSON.stringify({ ok: rows.length > 0, rows, message: rows.length ? '' : 'mapping contained no messages' })
+  } catch (error) {
+    return JSON.stringify({ ok: false, message: String(error && error.message || error) })
+  }
+}`
+
+registerProvider({
+  site: 'dsh-chatgpt', provider: 'ChatGPT', domain: 'chatgpt.com', home: 'https://chatgpt.com/',
+  conversationUrl: id => `https://chatgpt.com/c/${encodeURIComponent(id)}`,
+  whoamiScript: String.raw`async function () {
+    const response = await fetch('/api/auth/session', { credentials: 'include' })
+    if (response.status === 401 || response.status === 403) return JSON.stringify({ ok: false, code: 'AUTH' })
+    if (!response.ok) return JSON.stringify({ ok: false, message: 'session HTTP ' + response.status })
+    const payload = await response.json(); const user = payload.user || payload.account || {}
+    const identity = String(user.id || user.account_id || user.email || '')
+    return JSON.stringify({ ok: Boolean(identity), identity, code: identity ? undefined : 'AUTH' })
+  }`,
+  historyScript, detailScript, fallbackScript: domFallbackScript,
+})