@aiwg/cli 2026.7.21 → 2026.7.24

package/dist/src/sessions/workspace-discovery.js

@@ -0,0 +1,319 @@
+import { createReadStream } from 'node:fs';
+import { access, mkdir, readFile, realpath, rename, stat, writeFile, } from 'node:fs/promises';
+import { homedir, userInfo } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { ClaudeSessionAdapter } from './adapters/claude.js';
+import { CodexSessionAdapter } from './adapters/codex.js';
+import { CursorSessionAdapter } from './adapters/cursor.js';
+import { FactorySessionAdapter } from './adapters/factory.js';
+import { SESSION_PROVIDER_IDS, sha256, } from './contracts.js';
+import { redactSourceLocator } from './discovery.js';
+import { fingerprintSourceFile } from './readers.js';
+export const DISCOVERY_MANIFEST_VERSION = '1.0.0';
+const MANUAL_EXPORT_PROVIDERS = new Set([
+    'copilot', 'hermes', 'opencode', 'openclaw', 'openhuman',
+    'warp', 'devin-desktop', 'generic',
+]);
+export async function discoverWorkspaceHistories(options) {
+    const workspacePath = await canonicalPath(options.workspace);
+    const workspaceId = workspacePath;
+    const providerHomes = providerHomeCandidates(options.providerHome, options.operatorHome);
+    const keyWithLeadingDash = workspaceKey(workspacePath, true);
+    const keyWithoutLeadingDash = workspaceKey(workspacePath, false);
+    const discoverable = [
+        {
+            provider: 'claude',
+            adapter: new ClaudeSessionAdapter(),
+            roots: providerHomes.map((providerHome) => join(providerHome, '.claude', 'projects', keyWithLeadingDash)),
+        },
+        {
+            provider: 'codex',
+            adapter: new CodexSessionAdapter(),
+            roots: options.codexRoot
+                ? [resolve(options.codexRoot)]
+                : options.providerHome
+                    ? [join(resolve(options.providerHome), '.codex', 'sessions')]
+                    : [],
+        },
+        {
+            provider: 'cursor',
+            adapter: new CursorSessionAdapter(),
+            roots: providerHomes.map((providerHome) => join(providerHome, '.cursor', 'projects', keyWithoutLeadingDash, 'agent-transcripts')),
+        },
+        {
+            provider: 'factory',
+            adapter: new FactorySessionAdapter(),
+            roots: providerHomes.flatMap((providerHome) => [
+                join(providerHome, '.factory', 'projects', keyWithLeadingDash),
+                join(providerHome, '.factory', 'sessions', keyWithLeadingDash),
+            ]),
+        },
+    ];
+    const reports = new Map();
+    const candidates = [];
+    const seen = new Set();
+    for (const entry of discoverable) {
+        const availableRoots = [];
+        for (const root of entry.roots) {
+            if (await pathExists(root))
+                availableRoots.push(await canonicalPath(root));
+        }
+        if (availableRoots.length === 0) {
+            const codexNeedsAuthorization = entry.provider === 'codex'
+                && entry.roots.length === 0;
+            reports.set(entry.provider, providerReport(entry.provider, codexNeedsAuthorization ? 'export-required' : 'unavailable', codexNeedsAuthorization ? 'manual-export' : 'discoverable', [], codexNeedsAuthorization
+                ? 'SHARED_ROOT_AUTHORIZATION_REQUIRED'
+                : 'PROVIDER_ROOT_UNAVAILABLE', codexNeedsAuthorization
+                ? 'Pass --codex-root with an explicitly authorized Codex sessions or App Server export root.'
+                : `No authorized ${entry.provider} workspace history root was found.`));
+            continue;
+        }
+        const scope = {
+            workspaceId,
+            allowedRoots: availableRoots,
+        };
+        const providerSources = [];
+        for await (const descriptor of entry.adapter.discover(scope)) {
+            const locator = await canonicalPath(descriptor.locator);
+            if (entry.provider === 'codex'
+                && !await codexSourceMatchesWorkspace(locator, workspacePath))
+                continue;
+            const details = await stat(locator);
+            const authorizedRoot = scope.allowedRoots.find((root) => locator === root || locator.startsWith(`${root}/`));
+            if (!authorizedRoot)
+                continue;
+            const fingerprint = await fingerprintSourceFile({
+                selectedPath: locator,
+                allowedRoots: [authorizedRoot],
+            });
+            const dedupeKey = `${entry.provider}\0${fingerprint.digest}\0${fingerprint.size}`;
+            if (seen.has(dedupeKey))
+                continue;
+            seen.add(dedupeKey);
+            const source = sourceFromDescriptor(descriptor, locator, authorizedRoot, details, fingerprint.digest);
+            providerSources.push(source);
+            candidates.push(source);
+        }
+        reports.set(entry.provider, providerReport(entry.provider, 'checked', 'discoverable', providerSources, providerSources.length === 0 ? 'NO_WORKSPACE_SOURCES' : null, providerSources.length === 0
+            ? `The ${entry.provider} root was checked, but no source matched the authorized workspace.`
+            : null));
+    }
+    for (const provider of SESSION_PROVIDER_IDS) {
+        if (reports.has(provider))
+            continue;
+        const manual = MANUAL_EXPORT_PROVIDERS.has(provider);
+        reports.set(provider, providerReport(provider, manual ? 'export-required' : 'not-checked', manual ? 'manual-export' : 'unsupported', [], manual ? 'EXPLICIT_EXPORT_REQUIRED' : 'PROVIDER_NOT_CHECKED', manual
+            ? `Select and authorize a supported ${provider} export before importing it.`
+            : `No discovery strategy is registered for ${provider}.`));
+    }
+    const sources = candidates.sort(compareSources);
+    const providers = [...reports.values()].sort((a, b) => a.provider.localeCompare(b.provider));
+    const identity = {
+        schemaVersion: DISCOVERY_MANIFEST_VERSION,
+        workspaceId,
+        sources: sources.map((source) => ({
+            sourceId: source.sourceId,
+            provider: source.provider,
+            locatorClass: source.locatorClass,
+            locator: source.locator,
+            modifiedAt: source.modifiedAt,
+            sizeBytes: source.sizeBytes,
+            digest: source.digest,
+        })),
+        providers: providers.map((provider) => ({
+            provider: provider.provider,
+            status: provider.status,
+            reasonCode: provider.reasonCode,
+        })),
+    };
+    return {
+        schemaVersion: DISCOVERY_MANIFEST_VERSION,
+        manifestId: sha256(JSON.stringify(identity)),
+        createdAt: options.createdAt ?? new Date().toISOString(),
+        workspaceId,
+        workspacePath,
+        providers,
+        sources,
+    };
+}
+export function defaultDiscoveryManifestPath(workspace) {
+    return resolve(workspace, '.aiwg', 'sessions', 'discovery-manifest.json');
+}
+export async function writeDiscoveryManifest(path, manifest) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.tmp-${process.pid}`;
+    await writeFile(temporary, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+    await rename(temporary, path);
+}
+export async function readDiscoveryManifest(path) {
+    const value = JSON.parse(await readFile(path, 'utf8'));
+    if (value.schemaVersion !== DISCOVERY_MANIFEST_VERSION
+        || typeof value.manifestId !== 'string'
+        || typeof value.workspaceId !== 'string'
+        || !Array.isArray(value.providers)
+        || !Array.isArray(value.sources)) {
+        throw new Error('session discovery manifest is malformed or unsupported');
+    }
+    const expected = await rediscoverManifestIdentity(value);
+    if (expected !== value.manifestId) {
+        throw new Error('session discovery manifest identity does not match its contents');
+    }
+    return value;
+}
+export function publicDiscoveryManifest(manifest) {
+    return {
+        schemaVersion: manifest.schemaVersion,
+        manifestId: manifest.manifestId,
+        createdAt: manifest.createdAt,
+        workspaceId: manifest.workspaceId,
+        workspacePath: manifest.workspacePath,
+        providers: manifest.providers,
+        sources: manifest.sources.map(({ locator: _locator, authorizedRoot: _root, ...source }) => source),
+        totals: {
+            providers: manifest.providers.length,
+            sources: manifest.sources.length,
+        },
+    };
+}
+function sourceFromDescriptor(descriptor, locator, authorizedRoot, details, digest) {
+    return {
+        sourceId: sha256([
+            'workspace-source-v1', descriptor.provider, descriptor.locatorClass, digest,
+        ].join('\0')),
+        provider: descriptor.provider,
+        locator,
+        redactedLocator: redactSourceLocator(locator),
+        locatorClass: descriptor.locatorClass,
+        authorizedRoot,
+        modifiedAt: details.mtime.toISOString(),
+        sizeBytes: Number(details.size),
+        digest,
+    };
+}
+function providerReport(provider, status, disposition, sources, reasonCode, remediation) {
+    const timestamps = sources.map((source) => source.modifiedAt).sort();
+    return {
+        provider,
+        status,
+        disposition,
+        sourceCount: sources.length,
+        dateRange: {
+            earliest: timestamps.at(0) ?? null,
+            latest: timestamps.at(-1) ?? null,
+        },
+        dateRangeBasis: 'source-mtime',
+        reasonCode,
+        remediation,
+    };
+}
+async function rediscoverManifestIdentity(manifest) {
+    const identity = {
+        schemaVersion: manifest.schemaVersion,
+        workspaceId: manifest.workspaceId,
+        sources: manifest.sources.map((source) => ({
+            sourceId: source.sourceId,
+            provider: source.provider,
+            locatorClass: source.locatorClass,
+            locator: source.locator,
+            modifiedAt: source.modifiedAt,
+            sizeBytes: source.sizeBytes,
+            digest: source.digest,
+        })),
+        providers: manifest.providers.map((provider) => ({
+            provider: provider.provider,
+            status: provider.status,
+            reasonCode: provider.reasonCode,
+        })),
+    };
+    return sha256(JSON.stringify(identity));
+}
+async function codexSourceMatchesWorkspace(locator, workspacePath) {
+    const input = createReadStream(locator, { encoding: 'utf8' });
+    const lines = createInterface({ input, crlfDelay: Infinity });
+    let count = 0;
+    try {
+        for await (const line of lines) {
+            if (++count > 50)
+                break;
+            let value;
+            try {
+                value = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const cwd = codexWorkspaceField(value);
+            if (!cwd)
+                continue;
+            try {
+                return await canonicalPath(cwd) === workspacePath;
+            }
+            catch {
+                return resolve(cwd) === workspacePath;
+            }
+        }
+        return false;
+    }
+    finally {
+        lines.close();
+        input.destroy();
+    }
+}
+function codexWorkspaceField(value) {
+    const root = asObject(value);
+    const payload = asObject(root.payload);
+    const result = asObject(root.result);
+    const resultThread = asObject(result.thread);
+    const params = asObject(root.params);
+    const paramsThread = asObject(params.thread);
+    for (const candidate of [
+        payload.cwd, result.cwd, resultThread.cwd, params.cwd, paramsThread.cwd,
+    ]) {
+        if (typeof candidate === 'string' && candidate.length > 0)
+            return candidate;
+    }
+    return null;
+}
+function asObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+async function canonicalPath(path) {
+    return realpath(resolve(path));
+}
+function workspaceKey(path, retainLeadingSeparator) {
+    const normalized = path.replace(/\\/g, '/');
+    const input = retainLeadingSeparator ? normalized : normalized.replace(/^\/+/, '');
+    return input.replace(/[/:]+/g, '-');
+}
+function providerHomeCandidates(explicit, operatorHome) {
+    if (explicit)
+        return [resolve(explicit)];
+    let accountHome = operatorHome;
+    if (!accountHome) {
+        try {
+            accountHome = userInfo().homedir;
+        }
+        catch {
+            accountHome = undefined;
+        }
+    }
+    return [...new Set([homedir(), accountHome].filter((candidate) => Boolean(candidate)).map((candidate) => resolve(candidate)))];
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function compareSources(left, right) {
+    return left.provider.localeCompare(right.provider)
+        || left.locator.localeCompare(right.locator)
+        || basename(left.locator).localeCompare(basename(right.locator));
+}
+//# sourceMappingURL=workspace-discovery.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiwg/cli",
-  "version": "2026.7.21",
+  "version": "2026.7.24",
   "description": "Lightweight AIWG CLI for signed, versioned web-backed resources.",
   "type": "module",
   "license": "MIT",