@axhub/acp 0.1.0

package/dist/lib/conversations/types.d.ts

@@ -0,0 +1,92 @@
+import type { AcpBuiltinToolSettings, AcpPermissionMode, AcpProviderKey } from "../acp2aisdk";
+export type ConversationStatus = "active" | "archived" | "deleted";
+export type ConversationSourceKind = "codex-jsonl";
+export type ConversationBuiltinToolSettings = AcpBuiltinToolSettings;
+export type ConversationRecord = {
+    threadId: string;
+    title: string | null;
+    titleOverride?: string | null;
+    createdAt: string;
+    updatedAt: string;
+    archivedAt: string | null;
+    deletedAt: string | null;
+    workspacePath: string;
+    provider: AcpProviderKey;
+    model: string | null;
+    modeId: string | null;
+    thoughtLevel: string | null;
+    permissionMode: AcpPermissionMode;
+    status: ConversationStatus;
+    builtinToolSettings?: ConversationBuiltinToolSettings | null;
+    providerSessionId?: string | null;
+    sourcePath?: string | null;
+    sourceKind?: ConversationSourceKind | null;
+    lastSeenMtime?: number | null;
+    lastActiveAt?: string | null;
+};
+export type ConversationSessionRecord = {
+    threadId: string;
+    acpSessionId: string | null;
+    provider: AcpProviderKey;
+    workspacePath: string;
+    model: string | null;
+    modeId: string | null;
+    thoughtLevel: string | null;
+    createdAt: string;
+    lastActivityAt: string;
+    closedAt: string | null;
+};
+export type StoredMessageEntry<TContent = Record<string, unknown>> = {
+    id: string;
+    parent_id: string | null;
+    format: string;
+    content: TContent;
+    createdAt: string;
+    updatedAt: string;
+};
+export type ConversationMessageRepository<TContent = Record<string, unknown>> = {
+    headId?: string | null;
+    messages: StoredMessageEntry<TContent>[];
+    diagnostic?: {
+        source: "provider-history" | "runtime-store";
+        error?: string;
+    };
+};
+export type ConversationStoreData = {
+    version: 1;
+    conversations: ConversationRecord[];
+    sessions: ConversationSessionRecord[];
+    messages?: Record<string, ConversationMessageRepository>;
+};
+export type ConversationMessageUpsertRequest<TContent = Record<string, unknown>> = {
+    parentId: string | null;
+    message: {
+        id: string;
+        content: TContent;
+    };
+    format: string;
+};
+export type ConversationListResponse = {
+    threads: ConversationRecord[];
+    nextCursor?: string;
+    total?: number;
+};
+export type ConversationListOptions = {
+    limit?: number;
+    after?: string | null;
+    refreshProvider?: boolean;
+};
+export type ConversationSessionResolution = {
+    thread: ConversationRecord;
+    source: "runtime-session" | "conversation" | "provider-history" | "thread";
+};
+export type ConversationUpsertRequest = Partial<Pick<ConversationRecord, "title" | "workspacePath" | "provider" | "model" | "modeId" | "thoughtLevel" | "permissionMode" | "builtinToolSettings" | "providerSessionId" | "sourcePath" | "sourceKind" | "lastSeenMtime" | "lastActiveAt">> & {
+    threadId: string;
+};
+export type ConversationInitializeResponse = {
+    thread: ConversationRecord;
+};
+export type ConversationRenameRequest = {
+    title: string;
+};
+export type ConversationMessagesResponse<TContent = Record<string, unknown>> = ConversationMessageRepository<TContent>;

package/dist/lib/local-image-files.d.ts

@@ -0,0 +1,5 @@
+export declare const LOCAL_IMAGE_FILE_EXTENSIONS: Set<string>;
+export declare function normalizeLocalFilePath(value: string): string | null;
+export declare function isLocalImageFilePath(value: string): boolean;
+export declare function isLocalFilePath(value: string): boolean;
+export declare function getImageMimeType(filePath: string): string;

package/dist/lib/local-image-files.mjs

@@ -0,0 +1,76 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
+const UNIX_LOCAL_PATH_RE = /^\/(?:Users|home|tmp|var|private|Volumes|mnt|media|opt)\//i;
+export const LOCAL_IMAGE_FILE_EXTENSIONS = new Set([
+    ".gif",
+    ".jpg",
+    ".jpeg",
+    ".png",
+    ".svg",
+    ".webp",
+]);
+const LOCAL_FILE_EXTENSION_RE = /^\.[A-Za-z0-9][A-Za-z0-9_-]{0,15}$/;
+export function normalizeLocalFilePath(value) {
+    const raw = value.trim();
+    if (!raw)
+        return null;
+    if (raw.startsWith("file://")) {
+        try {
+            return fileURLToPath(raw);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    if (/^https?:\/\//i.test(raw)) {
+        try {
+            const url = new URL(raw);
+            if (!LOCAL_HOSTS.has(url.hostname))
+                return null;
+            const pathname = decodeURIComponent(url.pathname);
+            return normalizeLocalFilePath(pathname);
+        }
+        catch (_b) {
+            return null;
+        }
+    }
+    const withoutQuery = raw.split(/[?#]/, 1)[0];
+    const windowsPath = withoutQuery.replace(/^\/([A-Za-z]:[\\/])/, "$1");
+    if (path.win32.isAbsolute(windowsPath)) {
+        return windowsPath;
+    }
+    if (UNIX_LOCAL_PATH_RE.test(withoutQuery) &&
+        path.posix.isAbsolute(withoutQuery)) {
+        return withoutQuery;
+    }
+    return null;
+}
+export function isLocalImageFilePath(value) {
+    const filePath = normalizeLocalFilePath(value);
+    if (!filePath)
+        return false;
+    const extension = path.extname(filePath).toLowerCase();
+    return LOCAL_IMAGE_FILE_EXTENSIONS.has(extension);
+}
+export function isLocalFilePath(value) {
+    const filePath = normalizeLocalFilePath(value);
+    if (!filePath)
+        return false;
+    return LOCAL_FILE_EXTENSION_RE.test(path.extname(filePath));
+}
+export function getImageMimeType(filePath) {
+    switch (path.extname(filePath).toLowerCase()) {
+        case ".gif":
+            return "image/gif";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".svg":
+            return "image/svg+xml";
+        case ".webp":
+            return "image/webp";
+        default:
+            return "image/png";
+    }
+}

package/dist/lib/local-image-paths.d.ts

@@ -0,0 +1,7 @@
+export declare function isLocalFilePath(value: string): boolean;
+export declare function isLocalImagePath(value: string): boolean;
+export declare function isRenderableImageUrl(value: string): boolean;
+export declare function getLocalImagePreviewUrl(value: string): string;
+export declare function getLocalFileName(value: string): string;
+export declare function getLocalImageFileName(value: string): string;
+export declare function markdownEscapeLinkDestination(value: string): string;

package/dist/lib/local-image-paths.mjs

@@ -0,0 +1,106 @@
+const IMAGE_EXTENSION_RE = /\.(?:png|jpe?g|webp|gif|svg)(?:[?#].*)?$/i;
+const FILE_EXTENSION_RE = /\.[A-Za-z0-9][A-Za-z0-9_-]{0,15}(?:[?#].*)?$/;
+const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "::1"]);
+const UNIX_LOCAL_PATH_RE = /^\/(?:Users|home|tmp|var|private|Volumes|mnt|media|opt)\//i;
+const WINDOWS_LOCAL_PATH_RE = /^(?:[A-Za-z]:[\\/]|\/[A-Za-z]:[\\/])/;
+const UNC_LOCAL_PATH_RE = /^\\\\[^\\/]+[\\/][^\\/]+[\\/]/;
+function trimPathValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("<") && trimmed.endsWith(">")) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function hasImageExtension(value) {
+    return IMAGE_EXTENSION_RE.test(value.split(/\s+/, 1)[0]);
+}
+function hasFileExtension(value) {
+    return FILE_EXTENSION_RE.test(value.split(/\s+/, 1)[0]);
+}
+function isLocalHostUrl(value) {
+    try {
+        const url = new URL(value);
+        return LOCAL_HOSTS.has(url.hostname);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function isLocalAbsolutePath(value) {
+    return (UNIX_LOCAL_PATH_RE.test(value) ||
+        WINDOWS_LOCAL_PATH_RE.test(value) ||
+        UNC_LOCAL_PATH_RE.test(value));
+}
+export function isLocalFilePath(value) {
+    const raw = trimPathValue(value);
+    if (!hasFileExtension(raw))
+        return false;
+    if (raw.startsWith("file://"))
+        return true;
+    if (/^https?:\/\//i.test(raw)) {
+        try {
+            const url = new URL(raw);
+            if (!LOCAL_HOSTS.has(url.hostname))
+                return false;
+            return isLocalAbsolutePath(decodeURIComponent(url.pathname));
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    return isLocalAbsolutePath(raw);
+}
+export function isLocalImagePath(value) {
+    const raw = trimPathValue(value);
+    if (!hasImageExtension(raw))
+        return false;
+    if (raw.startsWith("file://"))
+        return true;
+    if (/^https?:\/\//i.test(raw)) {
+        try {
+            const url = new URL(raw);
+            if (!LOCAL_HOSTS.has(url.hostname))
+                return false;
+            return isLocalAbsolutePath(decodeURIComponent(url.pathname));
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    return isLocalAbsolutePath(raw);
+}
+export function isRenderableImageUrl(value) {
+    const raw = trimPathValue(value);
+    if (isLocalImagePath(raw))
+        return false;
+    if (/^data:image\//i.test(raw))
+        return true;
+    if (/^https?:\/\//i.test(raw))
+        return hasImageExtension(raw);
+    if (raw.startsWith("/") && !raw.startsWith("//"))
+        return hasImageExtension(raw);
+    return false;
+}
+export function getLocalImagePreviewUrl(value) {
+    return `/api/local-files/image?path=${encodeURIComponent(trimPathValue(value))}`;
+}
+export function getLocalFileName(value) {
+    const raw = trimPathValue(value);
+    let pathValue = raw;
+    if (raw.startsWith("file://") || isLocalHostUrl(raw)) {
+        try {
+            pathValue = decodeURIComponent(new URL(raw).pathname);
+        }
+        catch (_a) {
+            pathValue = raw;
+        }
+    }
+    const withoutQuery = pathValue.split(/[?#]/, 1)[0].replace(/\\/g, "/");
+    return withoutQuery.split("/").filter(Boolean).at(-1) || "本地文件";
+}
+export function getLocalImageFileName(value) {
+    return getLocalFileName(value) || "本地图片";
+}
+export function markdownEscapeLinkDestination(value) {
+    return trimPathValue(value).replaceAll(">", "%3E");
+}

package/dist/lib/output-artifacts/workspace.d.ts

@@ -0,0 +1,8 @@
+import type { AcpOutputArtifact } from "../../components/assistant-ui/addons/output-artifacts";
+type ScanWorkspaceOutputArtifactsOptions = {
+    workspacePath: string | null | undefined;
+    threadId: string;
+    sinceMs: number;
+};
+export declare function scanWorkspaceOutputArtifacts(options: ScanWorkspaceOutputArtifactsOptions): Promise<AcpOutputArtifact[]>;
+export {};

package/dist/lib/output-artifacts/workspace.mjs

@@ -0,0 +1,174 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const MAX_SCAN_FILES = 8000;
+const MAX_TEXT_BYTES = 1024 * 1024;
+const EXCLUDED_DIRS = new Set([
+    ".git",
+    ".next",
+    ".turbo",
+    "automation-reports",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "tmp-midscene",
+    "tmp-regression",
+]);
+const TEXT_EXTENSIONS = new Set([
+    ".css",
+    ".drawio",
+    ".excalidraw",
+    ".html",
+    ".js",
+    ".jsx",
+    ".json",
+    ".md",
+    ".mdx",
+    ".svg",
+    ".ts",
+    ".tsx",
+    ".txt",
+    ".xml",
+]);
+const IMAGE_EXTENSIONS = new Set([
+    ".gif",
+    ".jpeg",
+    ".jpg",
+    ".png",
+    ".svg",
+    ".webp",
+]);
+const DOCUMENT_EXTENSIONS = new Set([
+    ".doc",
+    ".docx",
+    ".md",
+    ".mdx",
+    ".pdf",
+    ".txt",
+]);
+function normalizeThreadId(value) {
+    return value.trim() || "default";
+}
+function normalizeRelativePath(value) {
+    return value.replace(/\\/g, "/").replace(/^\/+/u, "");
+}
+function isWithinWorkspace(root, filePath) {
+    const relativePath = path.relative(root, filePath);
+    return Boolean(relativePath && !relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}
+function isExcludedRelativePath(relativePath) {
+    const parts = normalizeRelativePath(relativePath).split("/");
+    if (parts[0] === ".axhub" && parts[1] === "sessions")
+        return true;
+    return parts.some((part) => EXCLUDED_DIRS.has(part));
+}
+function extensionOf(relativePath) {
+    return path.extname(relativePath.split(/[?#]/u)[0] || "").toLowerCase();
+}
+function hasDrawioSignal(relativePath) {
+    return /(^|[./_-])drawio([./_-]|$)/iu.test(relativePath);
+}
+function isPrototypeArtifact(relativePath) {
+    return /^src\/prototypes\/[^/]+\/(?!canvas\.excalidraw$).+/iu.test(relativePath);
+}
+function isCanvasArtifact(relativePath) {
+    return /(^|\/)src\/prototypes\/[^/]+\/canvas\.excalidraw$/iu.test(relativePath);
+}
+function isResourceArtifact(relativePath) {
+    return /^src\/resources\//iu.test(relativePath);
+}
+function isOutputArtifactPath(relativePath) {
+    const normalized = normalizeRelativePath(relativePath);
+    if (isCanvasArtifact(normalized) || isPrototypeArtifact(normalized)) {
+        return true;
+    }
+    const extension = extensionOf(normalized);
+    if (isResourceArtifact(normalized)) {
+        return (IMAGE_EXTENSIONS.has(extension) ||
+            DOCUMENT_EXTENSIONS.has(extension) ||
+            hasDrawioSignal(normalized));
+    }
+    return (DOCUMENT_EXTENSIONS.has(extension) ||
+        IMAGE_EXTENSIONS.has(extension) ||
+        hasDrawioSignal(normalized));
+}
+function artifactPriority(relativePath) {
+    const extension = extensionOf(relativePath);
+    if (isPrototypeArtifact(relativePath))
+        return 0;
+    if (IMAGE_EXTENSIONS.has(extension) && !hasDrawioSignal(relativePath)) {
+        return 1;
+    }
+    if (hasDrawioSignal(relativePath))
+        return 2;
+    if (DOCUMENT_EXTENSIONS.has(extension))
+        return 3;
+    if (isCanvasArtifact(relativePath))
+        return 4;
+    return 5;
+}
+function statusFromStat(stat, sinceMs) {
+    return stat.birthtimeMs >= sinceMs - 1 ? "新增" : "修改";
+}
+async function readTextIfSafe(filePath, size) {
+    if (size > MAX_TEXT_BYTES || !TEXT_EXTENSIONS.has(extensionOf(filePath))) {
+        return undefined;
+    }
+    return fs.readFile(filePath, "utf8").catch(() => undefined);
+}
+async function collectCandidateFiles(root) {
+    const files = [];
+    const visit = async (directory) => {
+        if (files.length >= MAX_SCAN_FILES)
+            return;
+        const entries = await fs.readdir(directory, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            if (files.length >= MAX_SCAN_FILES)
+                return;
+            const filePath = path.join(directory, entry.name);
+            const relativePath = normalizeRelativePath(path.relative(root, filePath));
+            if (isExcludedRelativePath(relativePath))
+                continue;
+            if (entry.isDirectory()) {
+                await visit(filePath);
+                continue;
+            }
+            if (!entry.isFile() || !isOutputArtifactPath(relativePath))
+                continue;
+            files.push(filePath);
+        }
+    };
+    await visit(root);
+    return files;
+}
+export async function scanWorkspaceOutputArtifacts(options) {
+    var _a;
+    const workspacePath = String((_a = options.workspacePath) !== null && _a !== void 0 ? _a : "").trim();
+    if (!workspacePath)
+        return [];
+    const root = path.resolve(/* turbopackIgnore: true */ workspacePath);
+    const rootStat = await fs.stat(root).catch(() => null);
+    if (!(rootStat === null || rootStat === void 0 ? void 0 : rootStat.isDirectory()))
+        return [];
+    const normalizedThreadId = normalizeThreadId(options.threadId);
+    const sinceMs = Number.isFinite(options.sinceMs) ? options.sinceMs : 0;
+    const toolCallId = `workspace-scan:${normalizedThreadId}`;
+    const files = await collectCandidateFiles(root);
+    const artifacts = [];
+    for (const filePath of files) {
+        if (!isWithinWorkspace(root, filePath))
+            continue;
+        const stat = await fs.stat(filePath).catch(() => null);
+        if (!(stat === null || stat === void 0 ? void 0 : stat.isFile()) || stat.mtimeMs < sinceMs)
+            continue;
+        const relativePath = normalizeRelativePath(path.relative(root, filePath));
+        const newText = await readTextIfSafe(filePath, stat.size);
+        artifacts.push(Object.assign({ id: `workspace:${normalizedThreadId}:${relativePath}`, kind: "diff", title: relativePath, detail: statusFromStat(stat, sinceMs), status: statusFromStat(stat, sinceMs), path: relativePath, toolCallId, updatedAt: Math.max(1, Math.round(stat.mtimeMs)) }, (newText !== undefined ? { newText } : {})));
+    }
+    return artifacts.sort((left, right) => {
+        const leftPath = left.path || "";
+        const rightPath = right.path || "";
+        const priorityDelta = artifactPriority(leftPath) - artifactPriority(rightPath);
+        return priorityDelta || leftPath.localeCompare(rightPath);
+    });
+}

package/dist/lib/provider-history/codex.d.ts

@@ -0,0 +1,4 @@
+import type { ProviderSessionMeta, ProviderTranscript } from "./types";
+export declare function scanCodexSessions(workspacePath?: string | null): Promise<ProviderSessionMeta[]>;
+export declare function findCodexSessionById(sessionId: string, workspacePath?: string | null): Promise<ProviderSessionMeta | null>;
+export declare function loadCodexTranscript(sourcePath: string): Promise<ProviderTranscript>;