om-memory-system 3.2.0-next.11 → 3.2.0-next.12

package/dist/importer/import-args.d.ts

@@ -7,7 +7,7 @@ import type { ImportPathMap } from "./importer.js";
  * external API and key).
  */
 export type ImportHost = "pi" | "opencode";
-export type ImportSurface = "session" | "cli";
+export type ImportSurface = "session" | "cli" | "web";
 export interface HistoryImportArgs {
     help: boolean;
     dryRun: boolean;
@@ -39,6 +39,28 @@ export declare function parseHistoryImportArgs(tokens: string[], options: {
     host: ImportHost;
     surface: ImportSurface;
 }): HistoryImportArgs;
+/**
+ * Options the Settings page sends. Sessions come from the page's selection
+ * and the source from a signed token, so there is no `session`,
+ * `maxSessions`, or `source` here.
+ */
+export interface WebImportOptions {
+    dryRun?: boolean;
+    force?: boolean;
+    skipMemories?: boolean;
+    skipProfile?: boolean;
+    model?: string;
+    scope?: HistoryImportArgs["scope"];
+    project?: string;
+    /** Epoch ms from the browser's local day start, or an ISO date. */
+    since?: string | number;
+    /** Epoch ms from the browser's local day end, or an ISO date. */
+    until?: string | number;
+    profileBatch?: number;
+    pathMaps?: ImportPathMap[];
+}
+/** Convert page fields to the shared CLI grammar, which performs validation. */
+export declare function webImportTokens(options: WebImportOptions, _host: ImportHost): string[];
 /** True when the run calls a model: a real import of memories or the profile. */
 export declare function importNeedsModel(args: HistoryImportArgs): boolean;
 export declare function historyImportUsage(host: ImportHost, surface: ImportSurface): string;

package/dist/importer/import-args.js

@@ -168,7 +168,7 @@ export function parseHistoryImportArgs(tokens, options) {
     if (result.project !== undefined && result.scope === "all-projects") {
         result.errors.push("--project cannot be combined with --scope=all-projects");
     }
-    if (options.surface === "session" && result.model !== undefined) {
+    if (options.surface !== "cli" && result.model !== undefined) {
         const separator = result.model.indexOf("/");
         if (separator < 1 || separator === result.model.length - 1) {
             result.errors.push(`--model must be provider/id, got "${result.model}"`);
@@ -176,6 +176,34 @@ export function parseHistoryImportArgs(tokens, options) {
     }
     return result;
 }
+/** Convert page fields to the shared CLI grammar, which performs validation. */
+export function webImportTokens(options, _host) {
+    const tokens = [];
+    for (const [field, flag] of [
+        ["dryRun", "--dry-run"],
+        ["force", "--force"],
+        ["skipMemories", "--skip-memories"],
+        ["skipProfile", "--skip-profile"],
+    ]) {
+        if (options[field])
+            tokens.push(flag);
+    }
+    for (const [field, flag] of [
+        ["model", "--model"],
+        ["scope", "--scope"],
+        ["project", "--project"],
+        ["since", "--since"],
+        ["until", "--until"],
+        ["profileBatch", "--profile-batch"],
+    ]) {
+        const value = options[field];
+        if (value !== undefined)
+            tokens.push(flag, String(value));
+    }
+    for (const map of options.pathMaps ?? [])
+        tokens.push("--map", `${map.from}=${map.to}`);
+    return tokens;
+}
 /** True when the run calls a model: a real import of memories or the profile. */
 export function importNeedsModel(args) {
     return !args.dryRun && (!args.skipMemories || !args.skipProfile);

package/dist/importer/import-project.d.ts

@@ -0,0 +1,16 @@
+import type { ImportPathMap } from "./importer.js";
+/** How a recorded session directory was turned into a project directory. */
+export type ProjectResolution = "mapped" | "recorded" | "worktree" | "unresolved";
+export interface ResolvedImportProject {
+    directory: string | null;
+    via: ProjectResolution;
+}
+/**
+ * One rule for both hosts, shared by the web session list and the importers so
+ * the listed set and the imported set always agree. An exact directory map
+ * wins, because it is an explicit user choice; a map whose target is missing
+ * leaves the session unresolved rather than silently falling back. OpenCode
+ * alone passes a project worktree, which stands in for a deleted sub-directory
+ * of the same project.
+ */
+export declare function resolveImportProject(recordedDirectory: string | null, maps?: ImportPathMap[], projectWorktree?: string | null): ResolvedImportProject;

package/dist/importer/import-project.js

@@ -0,0 +1,35 @@
+import { statSync } from "node:fs";
+function isDirectory(path) {
+    if (!path)
+        return false;
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * One rule for both hosts, shared by the web session list and the importers so
+ * the listed set and the imported set always agree. An exact directory map
+ * wins, because it is an explicit user choice; a map whose target is missing
+ * leaves the session unresolved rather than silently falling back. OpenCode
+ * alone passes a project worktree, which stands in for a deleted sub-directory
+ * of the same project.
+ */
+export function resolveImportProject(recordedDirectory, maps = [], projectWorktree = null) {
+    if (!recordedDirectory)
+        return { directory: null, via: "unresolved" };
+    const map = maps.find((item) => item.from === recordedDirectory);
+    if (map) {
+        return isDirectory(map.to)
+            ? { directory: map.to, via: "mapped" }
+            : { directory: null, via: "unresolved" };
+    }
+    if (isDirectory(recordedDirectory))
+        return { directory: recordedDirectory, via: "recorded" };
+    if (projectWorktree && projectWorktree !== "/" && isDirectory(projectWorktree)) {
+        return { directory: projectWorktree, via: "worktree" };
+    }
+    return { directory: null, via: "unresolved" };
+}

package/dist/importer/import-readiness.d.ts

@@ -0,0 +1,47 @@
+/**
+ * What a real web import could use right now, checked inside the OpenCode
+ * process that runs it. `env://` and `file://` keys were resolved when the
+ * config loaded, so a variable set only in the user's shell shows as missing.
+ * "Ready" means configured, not tested: the Health section runs test calls.
+ */
+export type ExternalApiState = "ready" | "missing-model" | "missing-url" | "missing-key" | "unsupported-provider";
+export interface ImportReadiness {
+    external: {
+        state: ExternalApiState;
+        provider: string;
+        model: string | null;
+    };
+    opencode: {
+        available: boolean;
+        models: Array<{
+            provider: string;
+            model: string;
+            name: string;
+        }>;
+    };
+    piReader: {
+        available: boolean;
+        reason?: string;
+    };
+}
+export interface ReadinessDeps {
+    supportedProviders?: () => Promise<string[]>;
+    listOpencodeModels?: () => Promise<{
+        available: boolean;
+        models?: Array<{
+            provider: string;
+            model: string;
+            name: string;
+        }>;
+    }>;
+    loadPiSdk?: () => Promise<unknown>;
+}
+/** Mirrors the checks in `selectImportModel`, without building a provider. */
+export declare function externalApiState(supportedProviders?: () => Promise<string[]>): Promise<ExternalApiState>;
+export declare function importReadiness(deps?: ReadinessDeps): Promise<ImportReadiness>;
+/** Why a job cannot start, or `null` when it can. */
+export declare function importBlockedReason(readiness: ImportReadiness, request: {
+    host: "pi" | "opencode";
+    needsModel: boolean;
+    modelChoice?: string;
+}): string | null;

package/dist/importer/import-readiness.js

@@ -0,0 +1,54 @@
+import { CONFIG } from "../config.js";
+const EXTERNAL_REASONS = {
+    "missing-model": "The external API has no memoryModel in the global config",
+    "missing-url": "The external API has no memoryApiUrl in the global config",
+    "missing-key": "The external API key is missing in the OpenCode process; check memoryApiKey and its env:// or file:// source",
+    "unsupported-provider": "The memoryProvider in the global config is not supported for imports",
+};
+/** Mirrors the checks in `selectImportModel`, without building a provider. */
+export async function externalApiState(supportedProviders = async () => (await import("../services/ai/ai-provider-factory.js")).AIProviderFactory.getSupportedProviders()) {
+    const provider = CONFIG.memoryProvider;
+    if (!(await supportedProviders()).includes(provider))
+        return "unsupported-provider";
+    if (provider !== "orcarouter") {
+        if (!CONFIG.memoryModel)
+            return "missing-model";
+        if (!CONFIG.memoryApiUrl)
+            return "missing-url";
+    }
+    if (!CONFIG.memoryApiKey)
+        return "missing-key";
+    return "ready";
+}
+export async function importReadiness(deps = {}) {
+    const [state, opencode, piReader] = await Promise.all([
+        externalApiState(deps.supportedProviders),
+        (deps.listOpencodeModels ??
+            (async () => (await import("../services/settings-models.js")).listOpencodeSettingsModels()))(),
+        (deps.loadPiSdk ?? (() => import("@earendil-works/pi-coding-agent")))().then(() => ({ available: true }), () => ({
+            available: false,
+            reason: "The Pi SDK (@earendil-works/pi-coding-agent) is not installed for OpenCode",
+        })),
+    ]);
+    return {
+        external: { state, provider: CONFIG.memoryProvider, model: CONFIG.memoryModel ?? null },
+        opencode: { available: opencode.available, models: opencode.models ?? [] },
+        piReader,
+    };
+}
+/** Why a job cannot start, or `null` when it can. */
+export function importBlockedReason(readiness, request) {
+    if (request.host === "pi" && !readiness.piReader.available) {
+        return readiness.piReader.reason ?? "The Pi session reader is unavailable";
+    }
+    if (!request.needsModel)
+        return null;
+    if (!request.modelChoice)
+        return "Choose an import model";
+    if (request.modelChoice === "external") {
+        const state = readiness.external.state;
+        return state === "ready" ? null : EXTERNAL_REASONS[state];
+    }
+    const connected = readiness.opencode.models.some((model) => `${model.provider}/${model.model}` === request.modelChoice);
+    return connected ? null : "The chosen OpenCode model is not connected";
+}

package/dist/importer/import-sessions.d.ts

@@ -0,0 +1,98 @@
+import type { HistoryImportArgs, ImportHost } from "./import-args.js";
+import { type ProjectResolution } from "./import-project.js";
+import { type ImportSourceIdentity } from "./import-sources.js";
+import type { ImportPathMap } from "./importer.js";
+/**
+ * Session metadata for the Settings page and the selection a job imports.
+ * Both come from `matchImportSessions`, so the list, its revision, and the
+ * imported set always use the same discovery and project rules.
+ */
+export declare const MAX_SELECTED_KEYS = 1000;
+export interface ImportSessionRow {
+    /** Selection key: the OpenCode session ID, or the Pi file path relative to the source. */
+    key: string;
+    sessionId: string | null;
+    createdAt: number | null;
+    recordedDirectory: string | null;
+    directory: string | null;
+    via: ProjectResolution;
+}
+export interface ImportMatchOptions {
+    host: ImportHost;
+    scope: HistoryImportArgs["scope"];
+    /** Absolute project directory; defaults to the server's working directory. */
+    project?: string;
+    pathMaps: ImportPathMap[];
+    cwd: string;
+}
+export declare class StaleSelectionError extends Error {
+    readonly status = 409;
+    constructor(message?: string);
+}
+interface Matched {
+    identity: ImportSourceIdentity;
+    /** Resolvable sessions in scope, newest first. */
+    matching: ImportSessionRow[];
+    /** Sessions whose directory cannot be resolved, in any scope. */
+    unresolved: ImportSessionRow[];
+    revision: string;
+}
+export declare function matchImportSessions(identity: ImportSourceIdentity, options: ImportMatchOptions, snapshotMode: "fresh" | "reuse" | "any"): Promise<Matched>;
+export interface ImportSessionPage {
+    source: {
+        kind: ImportSourceIdentity["kind"];
+        displayPath: string;
+        sourceToken: string;
+    };
+    total: number;
+    offset: number;
+    rows: Array<ImportSessionRow & {
+        selectable: boolean;
+    }>;
+    /** Sessions whose recorded directory no longer exists. */
+    unresolvedCount: number;
+    revision: string;
+    listedAt: number;
+}
+export interface SessionListRequest {
+    sourceToken?: unknown;
+    offset?: number;
+    limit?: number;
+    refresh?: boolean;
+    match: Omit<ImportMatchOptions, "cwd">;
+}
+/** Check a session-list request body from the page. */
+export declare function validateSessionListRequest(value: unknown): SessionListRequest;
+/** One page of session metadata; no prompts, replies, or tool data. */
+export declare function listImportSessions(request: {
+    sourceToken?: unknown;
+    offset?: number;
+    limit?: number;
+    refresh?: boolean;
+}, options: ImportMatchOptions): Promise<ImportSessionPage>;
+export type ImportSelection = {
+    mode: "ids";
+    sessions: Array<{
+        key: string;
+        directory: string;
+    }>;
+    listedAt: number;
+} | {
+    mode: "all";
+    excludedKeys: string[];
+    revision: string;
+    listedAt: number;
+};
+export declare function validateImportSelection(value: unknown): ImportSelection;
+export interface ResolvedImportSelection {
+    identity: ImportSourceIdentity;
+    keys: string[];
+    cutoff: number;
+}
+/**
+ * Re-resolve a selection against the source right before a job. New sessions
+ * make an "all" selection stale; a missing or re-projected session makes an
+ * "ids" selection stale. Neither ever imports a session the user did not see.
+ */
+export declare function resolveImportSelection(sourceToken: unknown, selection: ImportSelection, options: ImportMatchOptions): Promise<ResolvedImportSelection>;
+export {};

package/dist/importer/import-sessions.js

@@ -0,0 +1,222 @@
+import { createHash } from "node:crypto";
+import { isAbsolute, resolve } from "node:path";
+import { discoverPiSessions } from "./discovery.js";
+import { resolveImportProject } from "./import-project.js";
+import { assertImportSourceUnchanged, importSourceKey, readImportSourceToken, validateImportSource, defaultImportSourcePath, } from "./import-sources.js";
+/**
+ * Session metadata for the Settings page and the selection a job imports.
+ * Both come from `matchImportSessions`, so the list, its revision, and the
+ * imported set always use the same discovery and project rules.
+ */
+export const MAX_SELECTED_KEYS = 1000;
+const MAX_PAGE = 200;
+export class StaleSelectionError extends Error {
+    status = 409;
+    constructor(message = "The session list is out of date. Refresh the list and try again.") {
+        super(message);
+        this.name = "StaleSelectionError";
+    }
+}
+async function readRows(identity, options, snapshotMode) {
+    if (options.host === "pi") {
+        return discoverPiSessions({ root: identity.realPath }).sessions.map((session) => ({
+            key: session.key,
+            sessionId: session.sessionId,
+            createdAt: session.timestamp,
+            recordedDirectory: session.cwd,
+            ...resolveImportProject(session.cwd, options.pathMaps),
+        }));
+    }
+    const { openOpencodeHistory } = await import("./opencode-reader.js");
+    const history = await openOpencodeHistory(identity.realPath, {}, { shared: { key: importSourceKey(identity), mode: snapshotMode } });
+    try {
+        return history.sessions.map((session) => ({
+            key: session.sessionId,
+            sessionId: session.sessionId,
+            createdAt: session.timeCreated,
+            recordedDirectory: session.recordedDirectory,
+            ...resolveImportProject(session.recordedDirectory, options.pathMaps, session.projectWorktree),
+        }));
+    }
+    finally {
+        await history.close();
+    }
+}
+/**
+ * The revision covers the source, the options that decide membership, and the
+ * sorted keys. It never uses file sizes or times: a live database changes on
+ * every message, and new turns in a listed session do not change the set.
+ */
+function revisionOf(identity, options, projectTag, keys) {
+    return createHash("sha256")
+        .update(JSON.stringify({
+        host: options.host,
+        source: importSourceKey(identity),
+        scope: options.scope,
+        project: projectTag,
+        maps: options.pathMaps,
+        keys: [...keys].sort(),
+    }))
+        .digest("hex");
+}
+export async function matchImportSessions(identity, options, snapshotMode) {
+    assertImportSourceUnchanged(identity);
+    const { projectFilterTag } = await import("./importer.js");
+    const projectTag = options.scope === "current-project"
+        ? projectFilterTag(resolve(options.cwd, options.project ?? "."))
+        : null;
+    // Map targets resolve against the working directory, as `runHistoryImport` does.
+    const rows = await readRows(identity, {
+        ...options,
+        pathMaps: options.pathMaps.map((map) => ({
+            from: map.from,
+            to: resolve(options.cwd, map.to),
+        })),
+    }, snapshotMode);
+    const unresolved = rows.filter((row) => row.directory === null);
+    const matching = rows
+        .filter((row) => row.directory !== null)
+        .filter((row) => projectTag === null || projectFilterTag(row.directory) === projectTag)
+        .sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0) || a.key.localeCompare(b.key));
+    return {
+        identity,
+        matching,
+        unresolved,
+        revision: revisionOf(identity, options, projectTag, matching.map((row) => row.key)),
+    };
+}
+/** Check a session-list request body from the page. */
+export function validateSessionListRequest(value) {
+    const input = value;
+    if (!input || typeof input !== "object")
+        throw new Error("Invalid session list request");
+    if (input.host !== "pi" && input.host !== "opencode")
+        throw new Error("Choose Pi or OpenCode");
+    const scope = input.scope ?? "current-project";
+    if (scope !== "current-project" && scope !== "all-projects")
+        throw new Error("Invalid scope");
+    const project = input.project;
+    if (project !== undefined && (typeof project !== "string" || !isAbsolute(project))) {
+        throw new Error("The project must be an absolute path");
+    }
+    const maps = input.pathMaps ?? [];
+    if (!Array.isArray(maps) ||
+        !maps.every((map) => map &&
+            typeof map.from === "string" &&
+            typeof map.to === "string")) {
+        throw new Error("Invalid directory maps");
+    }
+    for (const key of ["offset", "limit"]) {
+        if (input[key] !== undefined && !Number.isSafeInteger(input[key])) {
+            throw new Error(`Invalid ${key}`);
+        }
+    }
+    return {
+        ...(input.source !== undefined ? { sourceToken: input.source } : {}),
+        ...(input.offset !== undefined ? { offset: input.offset } : {}),
+        ...(input.limit !== undefined ? { limit: input.limit } : {}),
+        refresh: input.refresh === true,
+        match: {
+            host: input.host,
+            scope,
+            ...(project ? { project } : {}),
+            pathMaps: maps,
+        },
+    };
+}
+/** One page of session metadata; no prompts, replies, or tool data. */
+export async function listImportSessions(request, options) {
+    const source = request.sourceToken === undefined
+        ? validateImportSource(options.host, defaultImportSourcePath(options.host))
+        : null;
+    const token = source?.sourceToken ?? request.sourceToken;
+    const identity = readImportSourceToken(token, options.host);
+    const offset = Math.max(0, Math.floor(request.offset ?? 0));
+    const limit = Math.min(MAX_PAGE, Math.max(1, Math.floor(request.limit ?? 50)));
+    // A refresh takes a fresh copy of a live database; paging reuses the current one.
+    const listedAt = Date.now();
+    const matched = await matchImportSessions(identity, options, request.refresh ? "fresh" : "any");
+    const rows = [
+        ...matched.matching.map((row) => ({ ...row, selectable: true })),
+        ...(options.scope === "all-projects"
+            ? matched.unresolved.map((row) => ({ ...row, selectable: false }))
+            : []),
+    ];
+    return {
+        source: { kind: identity.kind, displayPath: identity.realPath, sourceToken: token },
+        total: rows.length,
+        offset,
+        rows: rows.slice(offset, offset + limit),
+        unresolvedCount: matched.unresolved.length,
+        revision: matched.revision,
+        listedAt,
+    };
+}
+export function validateImportSelection(value) {
+    const input = value;
+    if (!input || typeof input !== "object")
+        throw new Error("Choose sessions to import");
+    const listedAt = input.listedAt;
+    if (typeof listedAt !== "number" || !Number.isFinite(listedAt) || listedAt > Date.now()) {
+        throw new Error("Invalid listing time");
+    }
+    if (input.mode === "ids") {
+        const sessions = input.sessions;
+        if (!Array.isArray(sessions) ||
+            sessions.length === 0 ||
+            !sessions.every((item) => item &&
+                typeof item.key === "string" &&
+                typeof item.directory === "string")) {
+            throw new Error("Choose sessions to import");
+        }
+        if (sessions.length > MAX_SELECTED_KEYS) {
+            throw new Error(`Select at most ${MAX_SELECTED_KEYS} sessions one by one, or use Select all matching`);
+        }
+        return {
+            mode: "ids",
+            sessions: sessions,
+            listedAt,
+        };
+    }
+    if (input.mode === "all") {
+        const excluded = input.excludedKeys ?? [];
+        if (!Array.isArray(excluded) || !excluded.every((key) => typeof key === "string")) {
+            throw new Error("Invalid excluded sessions");
+        }
+        if (typeof input.revision !== "string")
+            throw new Error("Invalid session list revision");
+        return { mode: "all", excludedKeys: excluded, revision: input.revision, listedAt };
+    }
+    throw new Error("Choose sessions to import");
+}
+/**
+ * Re-resolve a selection against the source right before a job. New sessions
+ * make an "all" selection stale; a missing or re-projected session makes an
+ * "ids" selection stale. Neither ever imports a session the user did not see.
+ */
+export async function resolveImportSelection(sourceToken, selection, options) {
+    const identity = readImportSourceToken(sourceToken, options.host);
+    const matched = await matchImportSessions(identity, options, "reuse").catch((error) => {
+        if (error.code === "expired")
+            throw new StaleSelectionError();
+        throw error;
+    });
+    let keys;
+    if (selection.mode === "all") {
+        if (matched.revision !== selection.revision)
+            throw new StaleSelectionError();
+        const excluded = new Set(selection.excludedKeys);
+        keys = matched.matching.map((row) => row.key).filter((key) => !excluded.has(key));
+    }
+    else {
+        const current = new Map(matched.matching.map((row) => [row.key, row.directory]));
+        for (const item of selection.sessions) {
+            if (current.get(item.key) !== item.directory)
+                throw new StaleSelectionError();
+        }
+        keys = selection.sessions.map((item) => item.key);
+    }
+    if (keys.length === 0)
+        throw new Error("Choose sessions to import");
+    return { identity, keys, cutoff: selection.listedAt };
+}

package/dist/importer/import-sources.d.ts

@@ -0,0 +1,47 @@
+import type { ImportHost } from "./import-args.js";
+/**
+ * History sources chosen on the Settings page. The browser never uploads a
+ * file: it names a server-side path, the server checks it once, and later
+ * requests carry a signed token that pins the real path, device, and inode.
+ */
+export type ImportSourceKind = "pi-folder" | "pi-file" | "opencode-db";
+export interface ImportSourceIdentity {
+    host: ImportHost;
+    kind: ImportSourceKind;
+    realPath: string;
+    dev: number;
+    ino: number;
+}
+export declare class ImportSourceError extends Error {
+    readonly status: number;
+    constructor(message: string, status?: number);
+}
+export declare function signImportSource(identity: ImportSourceIdentity): string;
+export declare function readImportSourceToken(token: unknown, host: ImportHost): ImportSourceIdentity;
+/** Stable key for sharing snapshots and computing revisions. */
+export declare function importSourceKey(identity: ImportSourceIdentity): string;
+/** Refuse a source whose path now names another file, such as a swapped-in symlink. */
+export declare function assertImportSourceUnchanged(identity: ImportSourceIdentity): void;
+export declare function defaultImportSourcePath(host: ImportHost): string;
+export interface ValidatedImportSource {
+    kind: ImportSourceKind;
+    displayPath: string;
+    sourceToken: string;
+}
+/** Check an absolute path's kind and format; never returns file contents. */
+export declare function validateImportSource(host: ImportHost, path: unknown): ValidatedImportSource;
+export interface BrowseEntry {
+    name: string;
+    path: string;
+    kind: "folder" | "pi-file" | "opencode-db";
+}
+/**
+ * One folder at a time, with no recursion: subfolders and files the host can
+ * import. Symlinked entries are hidden. Only offered on loopback binds.
+ */
+export declare function browseImportSources(host: ImportHost, path?: unknown): {
+    path: string;
+    parent: string | null;
+    entries: BrowseEntry[];
+    truncated: boolean;
+};