@yuandc/aica 0.1.0

package/dist/core/affected-files.js

@@ -0,0 +1,268 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+const MAX_HASH_BYTES = 50 * 1024 * 1024;
+const PATH_KEYS = ["path", "file", "filePath", "file_path", "filename", "targetPath", "target_path", "move_path"];
+export function captureGitSnapshot(cwd) {
+    if (!isGitWorktree(cwd))
+        return null;
+    const entries = parseGitStatus(cwd);
+    if (!entries)
+        return null;
+    const snapshot = new Map();
+    for (const entry of entries) {
+        snapshot.set(entry.path, {
+            status: entry.status,
+            objectHash: entry.status.includes("D") ? null : gitObjectHash(cwd, entry.path)
+        });
+    }
+    return snapshot;
+}
+export function collectAffectedFiles(input) {
+    const items = new Map();
+    for (const filePath of input.evidencePaths) {
+        addAffectedFile(items, input.cwd, filePath, "unknown", "acp_tool");
+    }
+    return [...items.values()]
+        .filter((item) => item.relativePath && !item.relativePath.startsWith(".git/"))
+        .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+export function extractAffectedFilePathsFromAcpRaw(raw) {
+    const paths = new Set();
+    visitRaw(raw, (value, key) => {
+        if (typeof value !== "string")
+            return;
+        if (looksLikeFilePathKey(key))
+            addPathCandidate(paths, value);
+        if (key === "command") {
+            for (const filePath of extractShellWritePaths(value))
+                addPathCandidate(paths, filePath);
+        }
+    });
+    visitDiffBlocks(raw, paths);
+    visitRawChanges(raw, paths);
+    return [...paths];
+}
+function addAffectedFile(items, cwd, filePath, changeType, source) {
+    const resolved = resolveInside(cwd, filePath);
+    if (!resolved)
+        return;
+    const existing = items.get(resolved.relativePath);
+    const stat = safeStat(resolved.absolutePath);
+    const next = {
+        path: resolved.absolutePath,
+        absolutePath: resolved.absolutePath,
+        relativePath: resolved.relativePath,
+        changeType: mergeChangeType(existing?.changeType, changeType),
+        source: existing?.source === "acp_tool" || existing?.source === "acp_diff" ? existing.source : source,
+        exists: Boolean(stat?.isFile()),
+        downloadable: Boolean(stat?.isFile()),
+        ...(stat?.isFile() ? {
+            size: stat.size,
+            mime: mimeForPath(resolved.absolutePath),
+            sha256: stat.size <= MAX_HASH_BYTES ? sha256File(resolved.absolutePath) : undefined
+        } : {})
+    };
+    items.set(resolved.relativePath, next);
+}
+function mergeChangeType(current, next) {
+    if (!current || current === "unknown")
+        return next;
+    if (next === "unknown")
+        return current;
+    if (current === next)
+        return current;
+    if (current === "created" && next === "modified")
+        return "created";
+    return next;
+}
+function resolveInside(root, filePath) {
+    if (!filePath || filePath.includes("\0"))
+        return null;
+    const rootAbs = path.resolve(root);
+    const absolutePath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(rootAbs, filePath);
+    const relativePath = path.relative(rootAbs, absolutePath).replace(/\\/g, "/");
+    if (!relativePath || relativePath.startsWith("..") || path.isAbsolute(relativePath))
+        return null;
+    return { absolutePath, relativePath };
+}
+function isGitWorktree(cwd) {
+    try {
+        execFileSync("git", ["-C", cwd, "rev-parse", "--is-inside-work-tree"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseGitStatus(cwd) {
+    try {
+        const output = execFileSync("git", ["-C", cwd, "status", "--porcelain=v1", "-z", "--untracked-files=all"], {
+            encoding: "buffer",
+            maxBuffer: 20 * 1024 * 1024
+        });
+        const parts = output.toString("utf8").split("\0").filter(Boolean);
+        const entries = [];
+        for (let index = 0; index < parts.length; index += 1) {
+            const item = parts[index];
+            const status = item.slice(0, 2);
+            const rest = item.slice(3);
+            if (!rest)
+                continue;
+            if (status.startsWith("R") || status.startsWith("C")) {
+                const target = parts[index + 1];
+                if (target) {
+                    entries.push({ status, path: target });
+                    index += 1;
+                }
+            }
+            else {
+                entries.push({ status, path: rest });
+            }
+        }
+        return entries;
+    }
+    catch {
+        return null;
+    }
+}
+function gitObjectHash(cwd, relativePath) {
+    try {
+        const output = execFileSync("git", ["-C", cwd, "hash-object", "--", relativePath], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            maxBuffer: 1024 * 1024
+        }).trim();
+        return /^[0-9a-f]{40,64}$/i.test(output) ? output : null;
+    }
+    catch {
+        return null;
+    }
+}
+function visitRaw(value, visitor, key, depth = 0) {
+    if (depth > 8)
+        return;
+    visitor(value, key);
+    if (!value || typeof value !== "object")
+        return;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            visitRaw(item, visitor, undefined, depth + 1);
+        return;
+    }
+    for (const [childKey, childValue] of Object.entries(value)) {
+        visitRaw(childValue, visitor, childKey, depth + 1);
+    }
+}
+function visitDiffBlocks(raw, paths) {
+    visitRaw(raw, (value) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return;
+        const record = value;
+        if (record.type !== "diff")
+            return;
+        addPathCandidate(paths, record.path);
+    });
+}
+function visitRawChanges(raw, paths) {
+    visitRaw(raw, (value, key) => {
+        if (key !== "changes" || !value || typeof value !== "object" || Array.isArray(value))
+            return;
+        for (const changePath of Object.keys(value)) {
+            addPathCandidate(paths, changePath);
+        }
+    });
+}
+function looksLikeFilePathKey(key) {
+    if (!key)
+        return false;
+    return PATH_KEYS.includes(key);
+}
+function addPathCandidate(paths, value) {
+    if (typeof value !== "string")
+        return;
+    const trimmed = cleanPathCandidate(value);
+    if (!trimmed || trimmed.length > 500 || trimmed.includes("\n"))
+        return;
+    if (trimmed === "." || trimmed === "..")
+        return;
+    paths.add(trimmed);
+}
+function cleanPathCandidate(value) {
+    // ACP/diff 输出里有时会把 “+19/-7 source=...” 拼在路径后面，这里只保留真实文件路径。
+    let candidate = value.trim();
+    candidate = candidate.replace(/\s+\+\d+\s*\/\s*-\d+(?:\s+.*)?$/, "");
+    candidate = candidate.replace(/\s+\(\s*\+\d+\s*[,/ ]\s*-\d+\s*\)(?:\s+.*)?$/, "");
+    candidate = candidate.replace(/\s+(?:source|event|workspace|session|last)=\S+.*$/, "");
+    const token = candidate.split(/\s+/)[0] || "";
+    if (token && /\.[A-Za-z][A-Za-z0-9+-]{0,12}$/.test(token))
+        candidate = token;
+    return candidate.replace(/^["']|["']$/g, "").trim();
+}
+function extractShellWritePaths(command) {
+    const paths = [];
+    const redirectPattern = /(?:^|\s)(?:\d?>|>>)\s*(?:"([^"]+)"|'([^']+)'|([^\s;&|<>]+))/g;
+    let match;
+    while ((match = redirectPattern.exec(command))) {
+        const value = match[1] || match[2] || match[3];
+        if (value)
+            paths.push(value);
+    }
+    const touchPattern = /(?:^|\s)touch\s+(?:"([^"]+)"|'([^']+)'|([^\s;&|<>]+))/g;
+    while ((match = touchPattern.exec(command))) {
+        const value = match[1] || match[2] || match[3];
+        if (value && !value.startsWith("-"))
+            paths.push(value);
+    }
+    return paths;
+}
+function safeStat(filePath) {
+    try {
+        return fs.statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function sha256File(filePath) {
+    try {
+        return crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+    }
+    catch {
+        return undefined;
+    }
+}
+function mimeForPath(filePath) {
+    switch (path.extname(filePath).toLowerCase()) {
+        case ".pdf":
+            return "application/pdf";
+        case ".md":
+        case ".markdown":
+            return "text/markdown; charset=utf-8";
+        case ".txt":
+        case ".log":
+            return "text/plain; charset=utf-8";
+        case ".json":
+            return "application/json; charset=utf-8";
+        case ".csv":
+            return "text/csv; charset=utf-8";
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        case ".zip":
+            return "application/zip";
+        case ".docx":
+            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+        case ".xlsx":
+            return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+        default:
+            return "application/octet-stream";
+    }
+}

package/dist/core/auth.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { readJsonFile, writeJsonFile } from "./fs.js";
+import { getCredentialsPath } from "./paths.js";
+const CredentialsSchema = z.object({
+    token: z.string().optional(),
+    user: z
+        .object({
+        id: z.string().optional(),
+        email: z.string().optional()
+    })
+        .passthrough()
+        .optional(),
+    machine: z
+        .object({
+        machineId: z.string().optional(),
+        machineName: z.string().optional()
+    })
+        .passthrough()
+        .optional()
+}).passthrough();
+export function loadCredentials() {
+    const raw = readJsonFile(getCredentialsPath());
+    if (!raw)
+        return null;
+    const parsed = CredentialsSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+}
+export function saveApiKeyCredential(apiKey, machineName) {
+    const credentials = {
+        token: apiKey,
+        user: { id: "local-user" },
+        machine: { machineId: "local-machine", machineName }
+    };
+    writeJsonFile(getCredentialsPath(), credentials);
+    return credentials;
+}

package/dist/core/file-transfer-worker.js

@@ -0,0 +1,169 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { acaServerRequest, acaServerStreamRequest } from "./aca-server-client.js";
+import { loadAcaConfig } from "./aca-config.js";
+import { getAcaHome } from "./paths.js";
+import { startLongPollWorker } from "./long-poll-worker.js";
+const LONG_POLL_WAIT_MS = 25_000;
+export function startFileTransferWorkerLoop(logger) {
+    return startLongPollWorker({
+        run: async () => {
+            const config = loadAcaConfig();
+            if (!config.token)
+                throw new Error("Worker 尚未配置认证令牌");
+            const response = await acaServerRequest("GET", `/api/client/file-requests/claim?machineId=${encodeURIComponent(config.machineId)}&waitMs=${LONG_POLL_WAIT_MS}`);
+            if (!response.item)
+                return;
+            try {
+                await streamFileRequest(response.item, config, logger);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                logger.warn(`file request failed request=${response.item.requestId}: ${message}`);
+                try {
+                    await failFileRequest(response.item.requestId, message);
+                }
+                catch (failError) {
+                    logger.warn(`file request fail callback failed request=${response.item.requestId}: ${failError instanceof Error ? failError.message : String(failError)}`);
+                }
+            }
+        },
+        onError: (error, retryMs) => logger.warn(`file transfer worker failed, retry in ${retryMs}ms: ${error instanceof Error ? error.message : String(error)}`)
+    });
+}
+async function failFileRequest(requestId, message) {
+    await acaServerRequest("POST", `/api/client/file-requests/${encodeURIComponent(requestId)}/fail`, { message });
+}
+async function streamFileRequest(request, config, logger) {
+    const project = config.projects.find((item) => item.projectId === request.projectId);
+    const projectRoot = expandProjectRoot(request.projectRoot || project?.rootPath || "");
+    if (!projectRoot)
+        throw new Error(`file request ${request.requestId} project root is unknown`);
+    const purpose = request.purpose === "temp-image" ? "temp-image" : "project-file";
+    const resolved = purpose === "temp-image"
+        ? resolveTempImageFile(request.path)
+        : resolveProjectFile(projectRoot, request.path);
+    const stat = fs.statSync(resolved);
+    if (!stat.isFile())
+        throw new Error(`file request ${request.requestId} target is not a file`);
+    if (stat.size > request.maxBytes)
+        throw new Error(`file request ${request.requestId} target is too large (${stat.size} bytes)`);
+    const mimeType = purpose === "temp-image" ? detectSafeTempImageMime(resolved) : mimeForPath(resolved);
+    logger.info(`streaming file request=${request.requestId} path=${resolved}`);
+    await acaServerStreamRequest("POST", `/api/client/file-requests/${encodeURIComponent(request.requestId)}/stream`, Readable.toWeb(fs.createReadStream(resolved)), {
+        "content-type": "application/octet-stream",
+        "x-aca-file-name": encodeURIComponent(path.basename(resolved)),
+        "x-aca-file-size": String(stat.size),
+        "x-aca-file-mime": mimeType
+    });
+}
+function resolveProjectFile(projectRoot, requestedPath) {
+    const root = fs.realpathSync(expandProjectRoot(projectRoot));
+    const candidate = path.isAbsolute(requestedPath)
+        ? requestedPath
+        : path.join(root, requestedPath);
+    const target = fs.realpathSync(candidate);
+    const relative = path.relative(root, target);
+    if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("requested file is outside project root");
+    }
+    return target;
+}
+export function resolveTempImageFile(requestedPath) {
+    const candidate = localPathFromUri(requestedPath);
+    if (!path.isAbsolute(candidate))
+        throw new Error("temporary image path must be absolute");
+    const sourceStat = fs.lstatSync(candidate);
+    if (sourceStat.isSymbolicLink())
+        throw new Error("temporary image cannot be a symbolic link");
+    if (!sourceStat.isFile())
+        throw new Error("temporary image target is not a regular file");
+    const tempRoot = fs.realpathSync(os.tmpdir());
+    const target = fs.realpathSync(candidate);
+    const relative = path.relative(tempRoot, target);
+    if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error("temporary image is outside the system temp directory");
+    }
+    return target;
+}
+export function detectSafeTempImageMime(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    const header = Buffer.alloc(16);
+    const file = fs.openSync(filePath, "r");
+    let bytesRead = 0;
+    try {
+        bytesRead = fs.readSync(file, header, 0, header.length, 0);
+    }
+    finally {
+        fs.closeSync(file);
+    }
+    const bytes = header.subarray(0, bytesRead);
+    if (extension === ".png" && bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) {
+        return "image/png";
+    }
+    if ([".jpg", ".jpeg"].includes(extension) && bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) {
+        return "image/jpeg";
+    }
+    if (extension === ".gif" && bytes.length >= 6 && ["GIF87a", "GIF89a"].includes(bytes.subarray(0, 6).toString("ascii"))) {
+        return "image/gif";
+    }
+    if (extension === ".webp" && bytes.length >= 12 && bytes.subarray(0, 4).toString("ascii") === "RIFF" && bytes.subarray(8, 12).toString("ascii") === "WEBP") {
+        return "image/webp";
+    }
+    throw new Error("temporary file is not a supported raster image");
+}
+function localPathFromUri(value) {
+    const trimmed = String(value || "").trim();
+    if (!trimmed.startsWith("file://"))
+        return trimmed;
+    try {
+        return decodeURIComponent(new URL(trimmed).pathname);
+    }
+    catch {
+        throw new Error("temporary image path is invalid");
+    }
+}
+function expandProjectRoot(value) {
+    if (!value)
+        return "";
+    if (value === "~")
+        return path.dirname(getAcaHome());
+    if (value.startsWith("~/"))
+        return path.join(path.dirname(getAcaHome()), value.slice(2));
+    return value;
+}
+function mimeForPath(filePath) {
+    switch (path.extname(filePath).toLowerCase()) {
+        case ".pdf":
+            return "application/pdf";
+        case ".md":
+        case ".markdown":
+            return "text/markdown; charset=utf-8";
+        case ".txt":
+        case ".log":
+            return "text/plain; charset=utf-8";
+        case ".html":
+            return "text/html; charset=utf-8";
+        case ".json":
+            return "application/json; charset=utf-8";
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        case ".zip":
+            return "application/zip";
+        case ".docx":
+            return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+        case ".xlsx":
+            return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+        default:
+            return "application/octet-stream";
+    }
+}

package/dist/core/fs.js

@@ -0,0 +1,28 @@
+import fs from "node:fs";
+import path from "node:path";
+export function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+export function writeJsonFile(file, value) {
+    ensureDir(path.dirname(file));
+    fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+export function readJsonFile(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export function removeFileIfExists(file) {
+    try {
+        fs.unlinkSync(file);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}