@yuandc/aica 0.1.0

package/dist/core/logger.js

@@ -0,0 +1,42 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ensureDir } from "./fs.js";
+import { getLogDir } from "./paths.js";
+const levelRank = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40
+};
+export class Logger {
+    scope;
+    minLevel;
+    file;
+    constructor(scope, minLevel = "info") {
+        this.scope = scope;
+        this.minLevel = minLevel;
+        const date = new Date().toISOString().slice(0, 10);
+        this.file = path.join(getLogDir(), `${date}.log`);
+        ensureDir(path.dirname(this.file));
+    }
+    debug(message) {
+        this.write("debug", message);
+    }
+    info(message) {
+        this.write("info", message);
+    }
+    warn(message) {
+        this.write("warn", message);
+    }
+    error(message) {
+        this.write("error", message);
+    }
+    write(level, message) {
+        const line = `${new Date().toISOString()} [${level.toUpperCase()}] [${this.scope}] ${message}`;
+        fs.appendFileSync(this.file, `${line}\n`, "utf8");
+        if (levelRank[level] >= levelRank[this.minLevel]) {
+            const writer = level === "error" ? process.stderr : process.stdout;
+            writer.write(`${line}\n`);
+        }
+    }
+}

package/dist/core/long-poll-worker.js

@@ -0,0 +1,26 @@
+export function startLongPollWorker(input) {
+    // 正常长轮询超时后立即续接；只有网络或服务错误才指数退避，防止重启时集中重连。
+    let stopped = false;
+    let failures = 0;
+    const loop = async () => {
+        while (!stopped) {
+            try {
+                await input.run();
+                failures = 0;
+            }
+            catch (error) {
+                if (stopped)
+                    break;
+                failures += 1;
+                const retryMs = Math.min(10_000, 500 * 2 ** Math.min(5, failures - 1)) + Math.floor(Math.random() * 250);
+                input.onError(error, retryMs);
+                await delay(retryMs);
+            }
+        }
+    };
+    void loop();
+    return { stop: () => { stopped = true; } };
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/core/machine-filesystem-worker.js

@@ -0,0 +1,352 @@
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { acaServerRequest } from "./aca-server-client.js";
+import { loadAcaConfig, upsertLocalProject } from "./aca-config.js";
+import { startLongPollWorker } from "./long-poll-worker.js";
+const LONG_POLL_WAIT_MS = 25_000;
+const MAX_DIRECTORY_ITEMS = 300;
+const FILESYSTEM_ROOTS_CACHE_MS = 30_000;
+let filesystemRootsCache = null;
+export function startMachineFilesystemWorkerLoop(logger) {
+    return startLongPollWorker({
+        run: async () => {
+            const config = loadAcaConfig();
+            if (!config.token)
+                throw new Error("Worker 尚未配置认证令牌");
+            const response = await acaServerRequest("GET", `/api/client/machine-operations/claim?machineId=${encodeURIComponent(config.machineId)}&waitMs=${LONG_POLL_WAIT_MS}`);
+            if (!response.item)
+                return;
+            try {
+                const result = await executeMachineOperation(response.item);
+                await acaServerRequest("POST", `/api/client/machine-operations/${encodeURIComponent(response.item.requestId)}/complete`, { result });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                logger.warn(`machine filesystem request failed request=${response.item.requestId}: ${message}`);
+                await acaServerRequest("POST", `/api/client/machine-operations/${encodeURIComponent(response.item.requestId)}/fail`, { message }).catch(() => undefined);
+            }
+        },
+        onError: (error, retryMs) => logger.warn(`machine filesystem worker failed, retry in ${retryMs}ms: ${error instanceof Error ? error.message : String(error)}`)
+    });
+}
+async function executeMachineOperation(request) {
+    if (request.operation === "filesystem_roots")
+        return listMachineFilesystemRoots();
+    if (request.operation === "list_directory") {
+        return listMachineDirectory({
+            directoryPath: String(request.payload.path || ""),
+            includeHidden: request.payload.includeHidden === true
+        });
+    }
+    if (request.operation === "register_project")
+        return registerMachineProject(request.payload);
+    if (request.operation === "list_project_directory")
+        return listProjectDirectory(request.payload);
+    throw new Error("不支持的 Machine 文件系统操作。 ");
+}
+export function listProjectDirectory(payload) {
+    const rootPath = canonicalProjectRoot(String(payload.rootPath || ""));
+    const relativePath = normalizeProjectRelativePath(String(payload.relativePath || ""));
+    const directoryPath = resolveProjectEntry(rootPath, relativePath, true);
+    const offset = Math.max(0, Number(payload.offset || 0));
+    const limit = Math.min(300, Math.max(20, Number(payload.limit || 200)));
+    const entries = fs.readdirSync(directoryPath, { withFileTypes: true })
+        .filter((entry) => !entry.isSymbolicLink())
+        .map((entry) => ({
+        name: entry.name,
+        path: projectRelativePath(rootPath, path.join(directoryPath, entry.name)),
+        type: entry.isDirectory() ? "directory" : entry.isFile() ? "file" : "other",
+        hidden: entry.name.startsWith("."),
+        extension: entry.isFile() ? path.extname(entry.name).slice(1).toLowerCase() : ""
+    }))
+        .filter((entry) => entry.type !== "other")
+        .sort((left, right) => {
+        if (left.type !== right.type)
+            return left.type === "directory" ? -1 : 1;
+        return left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: "base" });
+    });
+    const items = entries.slice(offset, offset + limit);
+    return {
+        path: relativePath,
+        rootKind: payload.rootKind === "worktree" ? "worktree" : "project",
+        items,
+        total: entries.length,
+        nextOffset: offset + items.length < entries.length ? offset + items.length : null
+    };
+}
+export function listMachineFilesystemRoots() {
+    const platform = process.platform;
+    const roots = cachedFilesystemRoots(platform);
+    return { platform, roots };
+}
+export function listMachineDirectory(input) {
+    if (!input.directoryPath.trim())
+        throw new Error("目录路径不能为空。");
+    return process.platform === "win32"
+        ? listWindowsDirectory(input.directoryPath, Boolean(input.includeHidden))
+        : listPosixDirectory(input.directoryPath, Boolean(input.includeHidden));
+}
+export function comparableMachinePath(value, platform = process.platform) {
+    const api = platform === "win32" ? path.win32 : path.posix;
+    const normalizedValue = api.normalize(value);
+    const root = api.parse(normalizedValue).root;
+    const normalized = normalizedValue.length > root.length ? normalizedValue.replace(/[\\/]+$/, "") : normalizedValue;
+    return platform === "win32" ? normalized.toLocaleLowerCase("en-US") : normalized;
+}
+function posixFilesystemRoots() {
+    const home = fs.realpathSync(os.homedir());
+    const roots = [{ id: "home", label: "用户目录", path: home, kind: "home", available: true }];
+    if (home !== path.parse(home).root)
+        roots.push({ id: "root", label: "文件系统", path: "/", kind: "root", available: true });
+    return roots;
+}
+function cachedFilesystemRoots(platform) {
+    if (filesystemRootsCache?.platform === platform && filesystemRootsCache.expiresAtMs > Date.now())
+        return filesystemRootsCache.roots;
+    const roots = platform === "win32" ? windowsFilesystemRoots() : posixFilesystemRoots();
+    filesystemRootsCache = { platform, roots, expiresAtMs: Date.now() + FILESYSTEM_ROOTS_CACHE_MS };
+    return roots;
+}
+function windowsFilesystemRoots() {
+    const home = fs.realpathSync.native(os.homedir());
+    const roots = new Map();
+    roots.set(comparableMachinePath(home, "win32"), { id: "home", label: "用户目录", path: home, kind: "home", available: true });
+    try {
+        const script = [
+            "$items = Get-CimInstance Win32_LogicalDisk | ForEach-Object {",
+            "  [PSCustomObject]@{ Name = $_.DeviceID; Root = ($_.DeviceID + '\\\\'); DriveType = $_.DriveType; VolumeName = $_.VolumeName }",
+            "}",
+            "@($items) | ConvertTo-Json -Compress"
+        ].join("\n");
+        const values = parsePowerShellJson(execPowerShell(script));
+        for (const value of values) {
+            const rootPath = String(value.Root || "");
+            if (!rootPath)
+                continue;
+            const driveType = Number(value.DriveType || 0);
+            const name = String(value.Name || rootPath.replace(/[\\/]+$/, ""));
+            const volume = String(value.VolumeName || "").trim();
+            roots.set(comparableMachinePath(rootPath, "win32"), {
+                id: `drive-${name.replace(/[^a-z0-9]+/gi, "").toLowerCase()}`,
+                label: volume ? `${volume} (${name})` : driveLabel(name, driveType),
+                path: rootPath,
+                kind: driveKind(driveType),
+                available: true
+            });
+        }
+    }
+    catch {
+        const rootPath = path.win32.parse(home).root;
+        roots.set(comparableMachinePath(rootPath, "win32"), { id: "drive-system", label: `系统盘 (${rootPath.replace(/\\$/, "")})`, path: rootPath, kind: "fixed", available: true });
+    }
+    return [...roots.values()];
+}
+function listPosixDirectory(directoryPath, includeHidden) {
+    const canonicalPath = canonicalDirectory(directoryPath);
+    const entries = fs.readdirSync(canonicalPath, { withFileTypes: true });
+    const directories = entries.filter((entry) => entry.isDirectory() && !entry.isSymbolicLink() && (includeHidden || !entry.name.startsWith(".")));
+    const items = directories
+        .slice(0, MAX_DIRECTORY_ITEMS)
+        .map((entry) => ({ name: entry.name, path: path.join(canonicalPath, entry.name), kind: "directory", hidden: entry.name.startsWith("."), hasChildren: true }));
+    items.sort((left, right) => left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: "base" }));
+    return directoryListing(canonicalPath, items, directories.length > MAX_DIRECTORY_ITEMS, "linux");
+}
+function listWindowsDirectory(directoryPath, includeHidden) {
+    const canonicalPath = canonicalDirectory(directoryPath);
+    const script = [
+        "$items = Get-ChildItem -LiteralPath $env:ACA_MACHINE_FS_PATH -Directory -Force -ErrorAction Stop | ForEach-Object {",
+        "  [PSCustomObject]@{ Name = $_.Name; FullName = $_.FullName; Attributes = $_.Attributes.ToString() }",
+        "}",
+        "@($items) | ConvertTo-Json -Compress"
+    ].join("\n");
+    const values = parsePowerShellJson(execPowerShell(script, { ACA_MACHINE_FS_PATH: canonicalPath }));
+    const items = values
+        .map((value) => {
+        const attributes = String(value.Attributes || "");
+        return {
+            name: String(value.Name || ""),
+            path: String(value.FullName || ""),
+            kind: "directory",
+            hidden: /Hidden|System/i.test(attributes),
+            hasChildren: true,
+            reparsePoint: /ReparsePoint/i.test(attributes)
+        };
+    })
+        .filter((entry) => entry.name && entry.path && !entry.reparsePoint && (includeHidden || !entry.hidden))
+        .slice(0, MAX_DIRECTORY_ITEMS)
+        .sort((left, right) => left.name.localeCompare(right.name, undefined, { numeric: true, sensitivity: "base" }));
+    return directoryListing(canonicalPath, items, values.length > MAX_DIRECTORY_ITEMS, "win32");
+}
+function directoryListing(canonicalPath, items, truncated, platform) {
+    const api = platform === "win32" ? path.win32 : path.posix;
+    const root = api.parse(canonicalPath).root;
+    const parent = comparableMachinePath(canonicalPath, platform) === comparableMachinePath(root, platform)
+        ? null
+        : api.dirname(canonicalPath);
+    return {
+        platform,
+        path: canonicalPath,
+        parentPath: parent,
+        breadcrumbs: pathBreadcrumbs(canonicalPath, platform),
+        readable: canAccess(canonicalPath, fs.constants.R_OK),
+        writable: canAccess(canonicalPath, fs.constants.W_OK),
+        items,
+        truncated
+    };
+}
+function pathBreadcrumbs(value, platform) {
+    const api = platform === "win32" ? path.win32 : path.posix;
+    const parsed = api.parse(value);
+    const relative = value.slice(parsed.root.length).split(/[\\/]+/).filter(Boolean);
+    const result = [{ label: parsed.root.replace(/[\\/]+$/, "") || parsed.root, path: parsed.root }];
+    let current = parsed.root;
+    for (const segment of relative) {
+        current = api.join(current, segment);
+        result.push({ label: segment, path: current });
+    }
+    return result;
+}
+async function registerMachineProject(payload) {
+    const workspaceId = String(payload.workspaceId || "").trim();
+    const name = String(payload.name || "").trim();
+    const projectType = payload.projectType === "chat_room" ? "chat_room" : "project";
+    if (!workspaceId || !name)
+        throw new Error("项目名称和工作区不能为空。");
+    const rootPath = canonicalDirectory(String(payload.path || ""));
+    fs.accessSync(rootPath, fs.constants.R_OK | fs.constants.W_OK);
+    const projects = await acaServerRequest("GET", `/api/projects?workspaceId=${encodeURIComponent(workspaceId)}`);
+    const existing = projects.items.find((item) => comparableMachinePath(item.root_path) === comparableMachinePath(rootPath));
+    const item = existing || (await acaServerRequest("POST", "/api/projects", {
+        projectId: randomUUID(),
+        workspaceId,
+        name,
+        rootPath,
+        source: "aica",
+        projectType
+    })).item;
+    upsertLocalProject(localProject(item));
+    return { project: item, duplicate: Boolean(existing) };
+}
+function localProject(item) {
+    return {
+        projectId: item.project_id,
+        workspaceId: item.workspace_id,
+        name: item.name,
+        rootPath: item.root_path
+    };
+}
+function canonicalDirectory(value) {
+    if (!value.trim() || !path.isAbsolute(value))
+        throw new Error("必须选择绝对目录路径。");
+    assertRequestedPathAllowed(value);
+    const stat = fs.statSync(value);
+    if (!stat.isDirectory())
+        throw new Error("选择的路径不是目录。");
+    const canonicalPath = fs.realpathSync.native(value);
+    assertBrowsePathAllowed(canonicalPath);
+    return canonicalPath;
+}
+function canonicalProjectRoot(value) {
+    if (!value.trim() || !path.isAbsolute(value))
+        throw new Error("项目根目录无效。");
+    const root = fs.realpathSync.native(value);
+    if (!fs.statSync(root).isDirectory())
+        throw new Error("项目根目录不存在。");
+    return root;
+}
+function normalizeProjectRelativePath(value) {
+    const normalized = value.replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+    if (!normalized)
+        return "";
+    if (normalized.includes("\0") || normalized.split("/").some((part) => !part || part === "." || part === "..")) {
+        throw new Error("项目相对路径无效。");
+    }
+    return normalized;
+}
+function resolveProjectEntry(rootPath, relativePath, requireDirectory) {
+    const candidate = relativePath ? path.join(rootPath, ...relativePath.split("/")) : rootPath;
+    const target = fs.realpathSync.native(candidate);
+    const relative = path.relative(rootPath, target);
+    if (relative.startsWith("..") || path.isAbsolute(relative))
+        throw new Error("目录超出项目范围。");
+    const stat = fs.statSync(target);
+    if (requireDirectory && !stat.isDirectory())
+        throw new Error("请求路径不是目录。");
+    return target;
+}
+function projectRelativePath(rootPath, targetPath) {
+    return path.relative(rootPath, targetPath).split(path.sep).join("/");
+}
+function assertRequestedPathAllowed(candidate) {
+    const api = process.platform === "win32" ? path.win32 : path.posix;
+    const allowed = cachedFilesystemRoots(process.platform).some((root) => {
+        const rootPath = String(root.path || "");
+        if (!rootPath)
+            return false;
+        const relative = api.relative(rootPath, candidate);
+        return relative === "" || (!relative.startsWith("..") && !api.isAbsolute(relative));
+    });
+    if (!allowed)
+        throw new Error("目录不在允许浏览的位置内。");
+}
+function assertBrowsePathAllowed(candidate) {
+    const api = process.platform === "win32" ? path.win32 : path.posix;
+    const allowed = cachedFilesystemRoots(process.platform).some((root) => {
+        const rootPath = String(root.path || "");
+        if (!rootPath)
+            return false;
+        const relative = api.relative(rootPath, candidate);
+        return relative === "" || (!relative.startsWith("..") && !api.isAbsolute(relative));
+    });
+    if (!allowed)
+        throw new Error("目录不在允许浏览的位置内。");
+}
+function canAccess(value, mode) {
+    try {
+        fs.accessSync(value, mode);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function execPowerShell(script, extraEnv = {}) {
+    return execFileSync("powershell.exe", ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", script], {
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: 8_000,
+        maxBuffer: 4 * 1024 * 1024,
+        env: { ...process.env, ...extraEnv }
+    }).replace(/^\uFEFF/, "").trim();
+}
+function parsePowerShellJson(value) {
+    if (!value)
+        return [];
+    const parsed = JSON.parse(value);
+    if (Array.isArray(parsed))
+        return parsed.filter((item) => Boolean(item && typeof item === "object"));
+    return parsed && typeof parsed === "object" ? [parsed] : [];
+}
+function driveKind(value) {
+    if (value === 2)
+        return "removable";
+    if (value === 3)
+        return "fixed";
+    if (value === 4)
+        return "network";
+    if (value === 5)
+        return "optical";
+    return "drive";
+}
+function driveLabel(name, type) {
+    if (type === 2)
+        return `移动磁盘 (${name})`;
+    if (type === 4)
+        return `网络驱动器 (${name})`;
+    if (type === 5)
+        return `光驱 (${name})`;
+    return `本地磁盘 (${name})`;
+}

package/dist/core/paths.js

@@ -0,0 +1,26 @@
+import os from "node:os";
+import path from "node:path";
+export function getAcaHome() {
+    return process.env.AICA_HOME || process.env.ACA_HOME || path.join(os.homedir(), ".aica");
+}
+export function getPidFile() {
+    return path.join(getAcaHome(), "daemon.pid");
+}
+export function getLogDir() {
+    return path.join(getAcaHome(), "logs");
+}
+export function getStateDir() {
+    return path.join(getAcaHome(), "state");
+}
+export function getSessionDbPath() {
+    return path.join(getStateDir(), "sessions.sqlite3");
+}
+export function getRuntimeStatePath() {
+    return path.join(getAcaHome(), "runtime-state.json");
+}
+export function getAcaConfigPath() {
+    return process.env.AICA_CONFIG || process.env.ACA_CONFIG || path.join(getAcaHome(), "config.json");
+}
+export function getCredentialsPath() {
+    return process.env.AICA_CREDENTIALS || process.env.ACA_CREDENTIALS || path.join(getAcaHome(), "credentials.json");
+}

package/dist/core/process-identity.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+export const ACA_WORKER_INSTANCE_ENV = "ACA_WORKER_INSTANCE_ID";
+export const ACA_WORKER_PID_ENV = "ACA_WORKER_PID";
+export const ACA_WORKER_START_TICKS_ENV = "ACA_WORKER_START_TICKS";
+export const ACA_ACP_CHILD_ENV = "ACA_ACP_RUNTIME_CHILD";
+export const ACA_ACP_OWNER_PID_ENV = "ACA_ACP_RUNTIME_OWNER_PID";
+export const ACA_ACP_OWNER_START_TICKS_ENV = "ACA_ACP_RUNTIME_OWNER_START_TICKS";
+export const ACA_ACP_WORKER_INSTANCE_ENV = "ACA_ACP_RUNTIME_WORKER_INSTANCE_ID";
+export function readProcessStartTicks(pid) {
+    try {
+        const value = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+        const closingParen = value.lastIndexOf(")");
+        if (closingParen < 0)
+            return null;
+        const fields = value.slice(closingParen + 2).trim().split(/\s+/);
+        return fields[19] || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function acpChildEnvironment(extra = {}) {
+    const ownerPid = process.env[ACA_WORKER_PID_ENV] || String(process.pid);
+    const ownerStartTicks = process.env[ACA_WORKER_START_TICKS_ENV] || readProcessStartTicks(Number(ownerPid)) || "";
+    const workerInstanceId = process.env[ACA_WORKER_INSTANCE_ENV] || "";
+    return {
+        ...process.env,
+        ...extra,
+        [ACA_ACP_CHILD_ENV]: "1",
+        [ACA_ACP_OWNER_PID_ENV]: ownerPid,
+        [ACA_ACP_OWNER_START_TICKS_ENV]: ownerStartTicks,
+        [ACA_ACP_WORKER_INSTANCE_ENV]: workerInstanceId
+    };
+}

package/dist/core/process.js

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import { getPidFile } from "./paths.js";
+import { ensureDir, removeFileIfExists } from "./fs.js";
+import path from "node:path";
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function readPidFile() {
+    try {
+        const raw = fs.readFileSync(getPidFile(), "utf8").trim();
+        const pid = Number(raw);
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export function writePidFile(pid) {
+    const file = getPidFile();
+    ensureDir(path.dirname(file));
+    fs.writeFileSync(file, `${pid}\n`, "utf8");
+}
+export function removePidFile() {
+    removeFileIfExists(getPidFile());
+}

package/dist/core/provider-health.js

@@ -0,0 +1,54 @@
+import { execFileSync } from "node:child_process";
+import { resolveCodexPath } from "../acp/providers/codex/codex-process.js";
+const PROVIDER_HEALTH_TTL_MS = 5 * 60 * 1000;
+let cache = null;
+export function providerHealthSnapshot() {
+    const now = Date.now();
+    if (cache && cache.expiresAtMs > now)
+        return cache.items;
+    const items = {
+        codex: probeProvider(resolveCodexPath()),
+        mimo: probeProvider(process.env.ACA_MIMO_COMMAND || "mimo"),
+        opencode: probeProvider(process.env.ACA_OPENCODE_COMMAND || "opencode")
+    };
+    cache = { expiresAtMs: now + PROVIDER_HEALTH_TTL_MS, items };
+    return items;
+}
+function probeProvider(command) {
+    const checkedAtMs = Date.now();
+    try {
+        const output = execFileSync(command, ["--version"], {
+            encoding: "utf8",
+            timeout: 8_000,
+            maxBuffer: 256 * 1024,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        return {
+            available: true,
+            status: "ready",
+            version: firstOutputLine(output),
+            checkedAtMs,
+            errorCode: null
+        };
+    }
+    catch (error) {
+        const code = errorCode(error);
+        return {
+            available: false,
+            status: code === "ENOENT" ? "unavailable" : "error",
+            version: null,
+            checkedAtMs,
+            errorCode: code === "ENOENT" ? "not_installed" : "probe_failed"
+        };
+    }
+}
+function firstOutputLine(value) {
+    const line = value.split(/\r?\n/).map((item) => item.trim()).find(Boolean);
+    return line ? line.slice(0, 120) : null;
+}
+function errorCode(error) {
+    if (!error || typeof error !== "object")
+        return null;
+    const code = error.code;
+    return typeof code === "string" ? code : null;
+}

package/dist/core/runtime-options.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { getAcaConfigPath, getAcaHome, getCredentialsPath } from "./paths.js";
+export function applyRuntimePathOptions(options) {
+    const runtimeHome = options.aicaHome || options.acaHome;
+    if (runtimeHome) {
+        process.env.AICA_HOME = path.resolve(runtimeHome);
+    }
+    const configPath = options.aicaConfig || options.acaConfig;
+    if (configPath) {
+        process.env.AICA_CONFIG = path.resolve(configPath);
+    }
+    migrateLegacyWorkerFiles();
+}
+/**
+ * AICA 与 ACA Server 使用不同运行目录。升级时只迁移 Worker 登录所需文件，
+ * 不复制 Server 数据库、证书、日志、PID、聊天目录或 worktree。
+ */
+function migrateLegacyWorkerFiles() {
+    const legacyHome = path.resolve(process.env.AICA_LEGACY_HOME || path.join(os.homedir(), ".aca"));
+    const targetHome = path.resolve(getAcaHome());
+    const defaultAicaHome = path.resolve(path.join(os.homedir(), ".aica"));
+    if (legacyHome === targetHome || targetHome !== defaultAicaHome)
+        return;
+    if (!process.env.AICA_CONFIG && !process.env.ACA_CONFIG) {
+        copyIfMissing(path.join(legacyHome, "config.json"), getAcaConfigPath());
+    }
+    if (!process.env.AICA_CREDENTIALS && !process.env.ACA_CREDENTIALS) {
+        copyIfMissing(path.join(legacyHome, "credentials.json"), getCredentialsPath());
+    }
+}
+function copyIfMissing(source, target) {
+    if (fs.existsSync(target) || !fs.existsSync(source))
+        return;
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.copyFileSync(source, target, fs.constants.COPYFILE_EXCL);
+}