paseo-acp-agy 1.1.8 → 1.2.0

package/dist/acp-server.d.ts

@@ -5,6 +5,7 @@ export declare class ACPServer {
     private input;
     private output;
     private binaryPath;
+    private skipNarration;
     private rl;
     private isRunning;
     constructor(options?: {
@@ -12,6 +13,7 @@ export declare class ACPServer {
         output?: Writable;
         sessionManager?: SessionManager;
         binaryPath?: string;
+        skipNarration?: boolean;
     });
     start(): void;
     private send;

package/dist/acp-server.js

@@ -1,6 +1,6 @@
 import readline from "node:readline";
 import { logger } from "./logger.js";
-import { ACP_METHODS, AVAILABLE_MODES, fetchAvailableModels, buildConfigOptionsForModel, extractPromptText, mapToolNameToKind, calculateUsageCostUsd, roundUsageCostUsd, getModelContextWindow, fetchAntigravityUsage, } from "./protocol.js";
+import { ACP_METHODS, AVAILABLE_MODES, AVAILABLE_PERMISSIONS, fetchAvailableModels, buildConfigOptionsForSession, extractPromptText, mapToolNameToKind, extractImageMarkdownLink, isNarrationText, calculateUsageCostUsd, roundUsageCostUsd, getModelContextWindow, fetchAntigravityUsage, } from "./protocol.js";
 import { SessionManager } from "./session.js";
 import { executeSlashCommand, AVAILABLE_SLASH_COMMANDS } from "./slash-commands.js";
 import { getShortVersion } from "./version.js";
@@ -21,12 +21,15 @@ export class ACPServer {
     input;
     output;
     binaryPath;
+    skipNarration;
     rl = null;
     isRunning = false;
     constructor(options = {}) {
         this.input = options.input || process.stdin;
         this.output = options.output || process.stdout;
         this.binaryPath = options.binaryPath || resolveDefaultAgyBinary();
+        this.skipNarration =
+            options.skipNarration ?? (process.env.AGY_ACP_SKIP_NARRATION === "true");
         this.sessionManager =
             options.sessionManager || new SessionManager({ defaultBinaryPath: this.binaryPath });
     }
@@ -112,7 +115,13 @@ export class ACPServer {
                 availableModels,
                 currentModelId: session.model,
             },
-            configOptions: buildConfigOptionsForModel(session.model, session.effort, availableModels),
+            configOptions: buildConfigOptionsForSession({
+                modelId: session.model,
+                currentEffort: session.effort,
+                currentMode: session.mode,
+                currentPermission: session.permission,
+                availableModels,
+            }),
         };
     }
     requireSession(sessionId) {
@@ -329,11 +338,19 @@ export class ACPServer {
                                 this.sendSuccess(id, { stopReason: "end_turn" });
                             break;
                         }
+                        let hasSentNonNarration = false;
                         const onStepUpdate = (event) => {
                             const step = event.step_update;
                             if (!step)
                                 return;
                             if (step.step_type === "agent_response" && step.text_delta) {
+                                if (this.skipNarration && !hasSentNonNarration) {
+                                    if (isNarrationText(step.text_delta)) {
+                                        logger.debug("Skipping pure narration text chunk", { delta: step.text_delta });
+                                        return;
+                                    }
+                                    hasSentNonNarration = true;
+                                }
                                 this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                     sessionId: session.id,
                                     update: {
@@ -343,6 +360,7 @@ export class ACPServer {
                                 });
                             }
                             else if (step.step_type === "thought" && step.text_delta) {
+                                hasSentNonNarration = true;
                                 this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
                                     sessionId: session.id,
                                     update: {
@@ -352,6 +370,7 @@ export class ACPServer {
                                 });
                             }
                             else if (step.step_type === "tool" && step.tool_info) {
+                                hasSentNonNarration = true;
                                 const toolCallId = `tool_${step.step_index}`;
                                 const toolName = step.tool_name || step.tool_info.name || "tool";
                                 const toolKind = mapToolNameToKind(toolName);
@@ -377,6 +396,16 @@ export class ACPServer {
                                             rawOutput: step.tool_info.output ?? "",
                                         },
                                     });
+                                    const imageMarkdown = extractImageMarkdownLink(toolName, step.tool_info.output, step.tool_info.parameters);
+                                    if (imageMarkdown) {
+                                        this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
+                                            sessionId: session.id,
+                                            update: {
+                                                sessionUpdate: "agent_message_chunk",
+                                                content: { type: "text", text: `\n\n${imageMarkdown}\n\n` },
+                                            },
+                                        });
+                                    }
                                 }
                                 else if (step.state === "ERROR") {
                                     this.sendNotification(ACP_METHODS.SESSION_UPDATE, {
@@ -496,6 +525,7 @@ export class ACPServer {
                     break;
                 }
                 case ACP_METHODS.SESSION_SET_MODE:
+                case ACP_METHODS.SESSION_SET_MODE_CAMEL:
                 case ACP_METHODS.SESSION_SET_MODE_ALIAS: {
                     const sessionId = String(params.sessionId || "");
                     const modeId = String(params.modeId || params.mode || "default");
@@ -516,6 +546,7 @@ export class ACPServer {
                     break;
                 }
                 case ACP_METHODS.SESSION_SET_MODEL:
+                case ACP_METHODS.SESSION_SET_MODEL_CAMEL:
                 case ACP_METHODS.SESSION_SET_MODEL_ALIAS: {
                     const sessionId = String(params.sessionId || "");
                     const session = this.requireSession(sessionId);
@@ -546,12 +577,19 @@ export class ACPServer {
                     if (parsedModel.effort)
                         session.setEffort(parsedModel.effort);
                     session.setModel(model.modelId);
-                    const configOptions = buildConfigOptionsForModel(session.model, session.effort, models);
+                    const configOptions = buildConfigOptionsForSession({
+                        modelId: session.model,
+                        currentEffort: session.effort,
+                        currentMode: session.mode,
+                        currentPermission: session.permission,
+                        availableModels: models,
+                    });
                     if (!isNotification)
                         this.sendSuccess(id, { configOptions });
                     break;
                 }
                 case ACP_METHODS.SESSION_SET_CONFIG_OPTION:
+                case ACP_METHODS.SESSION_SET_CONFIG_OPTION_CAMEL:
                 case ACP_METHODS.SESSION_SET_CONFIG_OPTION_ALIAS: {
                     const sessionId = String(params.sessionId || "");
                     const configId = String(params.configId || "");
@@ -584,12 +622,36 @@ export class ACPServer {
                         session.setModel(value);
                         logger.info("Updated model for session via config option", { sessionId, model: value });
                     }
+                    else if (configId === "mode") {
+                        if (!AVAILABLE_MODES.some((candidate) => candidate.id === value)) {
+                            if (!isNotification)
+                                this.sendError(id, -32602, `Unsupported mode: ${value}`);
+                            break;
+                        }
+                        session.setMode(value);
+                        logger.info("Updated mode for session via config option", { sessionId, mode: value });
+                    }
+                    else if (configId === "permission") {
+                        if (!AVAILABLE_PERMISSIONS.some((candidate) => candidate.id === value)) {
+                            if (!isNotification)
+                                this.sendError(id, -32602, `Unsupported permission: ${value}`);
+                            break;
+                        }
+                        session.setPermission(value);
+                        logger.info("Updated permission for session via config option", { sessionId, permission: value });
+                    }
                     else {
                         if (!isNotification)
                             this.sendError(id, -32602, `Unsupported config option: ${configId}`);
                         break;
                     }
-                    const configOptions = buildConfigOptionsForModel(session.model, session.effort, models);
+                    const configOptions = buildConfigOptionsForSession({
+                        modelId: session.model,
+                        currentEffort: session.effort,
+                        currentMode: session.mode,
+                        currentPermission: session.permission,
+                        availableModels: models,
+                    });
                     if (!isNotification)
                         this.sendSuccess(id, { configOptions });
                     break;

package/dist/antigravity-process.d.ts

@@ -1,7 +1,10 @@
 import { EventEmitter } from "node:events";
 import { AgyInitEvent, AgyStepUpdateEvent, AgyResultEvent } from "./protocol.js";
 import { PermissionSettings } from "./permissions.js";
-export declare function resolveDefaultAgyBinary(): string;
+export declare const BINARY_RESOLVE_TTL_MS: number;
+export declare function clearBinaryResolutionCache(): void;
+export declare function isWindowsBatchScript(filePath: string): boolean;
+export declare function resolveDefaultAgyBinary(force?: boolean): string;
 export interface AntigravityProcessOptions {
     binaryPath?: string;
     cwd?: string;
@@ -37,6 +40,8 @@ export declare class AntigravityProcess extends EventEmitter {
     setModel(model: string): void;
     setEffort(effort: string): void;
     setMode(mode: string): void;
+    get currentPermissions(): PermissionSettings;
+    setPermissions(permissions: Partial<PermissionSettings>): void;
     setConversationId(conversationId?: string): void;
     private scheduleRestart;
     private isProcessTreeAlive;

package/dist/antigravity-process.js

@@ -6,54 +6,120 @@ import path from "node:path";
 import { logger } from "./logger.js";
 import { getEffectiveEffortForModel, } from "./protocol.js";
 import { buildAgyArgs, resolvePermissionSettings } from "./permissions.js";
-export function resolveDefaultAgyBinary() {
-    if (process.env.AGY_BIN_PATH)
-        return process.env.AGY_BIN_PATH;
-    const home = os.homedir();
-    if (home) {
-        if (process.platform === "win32") {
-            const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
-            const localAppData = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
-            const programFiles = process.env.ProgramFiles || "C:\\Program Files";
-            const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
-            const candidates = [
-                path.join(home, ".local", "bin", "agy.exe"),
-                path.join(home, ".local", "bin", "agy.cmd"),
-                path.join(home, ".local", "bin", "agy.bat"),
-                path.join(appData, "npm", "agy.cmd"),
-                path.join(appData, "npm", "agy.exe"),
-                path.join(appData, "npm", "agy.bat"),
-                path.join(localAppData, "npm", "agy.cmd"),
-                path.join(localAppData, "npm", "agy.exe"),
-                path.join(localAppData, "Programs", "antigravity", "agy.exe"),
-                path.join(localAppData, "Programs", "Antigravity", "bin", "agy.exe"),
-                path.join(localAppData, "Microsoft", "WindowsApps", "agy.exe"),
-                path.join(programFiles, "Antigravity", "bin", "agy.exe"),
-                path.join(programFilesX86, "Antigravity", "bin", "agy.exe"),
-            ];
-            for (const cand of candidates) {
-                if (fs.existsSync(cand))
-                    return cand;
+let cachedBinaryPath = null;
+let lastBinaryResolveTime = 0;
+export const BINARY_RESOLVE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours TTL
+export function clearBinaryResolutionCache() {
+    cachedBinaryPath = null;
+    lastBinaryResolveTime = 0;
+}
+export function isWindowsBatchScript(filePath) {
+    return /\.(cmd|bat)$/i.test(filePath);
+}
+export function resolveDefaultAgyBinary(force = false) {
+    const now = Date.now();
+    if (!force &&
+        cachedBinaryPath &&
+        now - lastBinaryResolveTime < BINARY_RESOLVE_TTL_MS &&
+        (cachedBinaryPath === "agy" || fs.existsSync(cachedBinaryPath))) {
+        return cachedBinaryPath;
+    }
+    let resolved = "agy";
+    if (process.env.AGY_BIN_PATH) {
+        resolved = process.env.AGY_BIN_PATH;
+    }
+    else {
+        const home = os.homedir();
+        if (home) {
+            if (process.platform === "win32") {
+                const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming");
+                const localAppData = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+                const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+                const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+                const exeCandidates = [
+                    path.join(localAppData, "Programs", "Antigravity", "bin", "agy.exe"),
+                    path.join(localAppData, "Programs", "antigravity", "agy.exe"),
+                    path.join(localAppData, "Programs", "Antigravity", "agy.exe"),
+                    path.join(programFiles, "Antigravity", "bin", "agy.exe"),
+                    path.join(programFilesX86, "Antigravity", "bin", "agy.exe"),
+                    path.join(localAppData, "Microsoft", "WindowsApps", "agy.exe"),
+                    path.join(home, ".local", "bin", "agy.exe"),
+                    path.join(appData, "npm", "agy.exe"),
+                    path.join(localAppData, "npm", "agy.exe"),
+                ];
+                for (const cand of exeCandidates) {
+                    if (fs.existsSync(cand)) {
+                        resolved = cand;
+                        break;
+                    }
+                }
+                if (resolved === "agy") {
+                    for (const target of ["agy", "agy.exe"]) {
+                        try {
+                            const out = execFileSync("where.exe", [target], {
+                                encoding: "utf-8",
+                                timeout: 2000,
+                                windowsHide: true,
+                            }).trim();
+                            const lines = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+                            for (const line of lines) {
+                                if (/\.exe$/i.test(line) && fs.existsSync(line)) {
+                                    resolved = line;
+                                    break;
+                                }
+                            }
+                            if (resolved !== "agy")
+                                break;
+                        }
+                        catch { }
+                    }
+                }
+                if (resolved === "agy") {
+                    const batchCandidates = [
+                        path.join(appData, "npm", "agy.cmd"),
+                        path.join(localAppData, "npm", "agy.cmd"),
+                        path.join(home, ".local", "bin", "agy.cmd"),
+                        path.join(appData, "npm", "agy.bat"),
+                    ];
+                    for (const cand of batchCandidates) {
+                        if (fs.existsSync(cand)) {
+                            resolved = cand;
+                            break;
+                        }
+                    }
+                    if (resolved === "agy") {
+                        for (const target of ["agy", "agy.cmd", "agy.bat"]) {
+                            try {
+                                const out = execFileSync("where.exe", [target], {
+                                    encoding: "utf-8",
+                                    timeout: 2000,
+                                    windowsHide: true,
+                                }).trim();
+                                const lines = out.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+                                for (const line of lines) {
+                                    if (isWindowsBatchScript(line) && fs.existsSync(line)) {
+                                        resolved = line;
+                                        break;
+                                    }
+                                }
+                                if (resolved !== "agy")
+                                    break;
+                            }
+                            catch { }
+                        }
+                    }
+                }
             }
-            try {
-                const out = execFileSync("where.exe", ["agy"], {
-                    encoding: "utf-8",
-                    timeout: 2000,
-                    windowsHide: true,
-                }).trim();
-                const first = out.split(/\r?\n/)[0]?.trim();
-                if (first && fs.existsSync(first))
-                    return first;
+            else {
+                const localPath = path.join(home, ".local", "bin", "agy");
+                if (fs.existsSync(localPath))
+                    resolved = localPath;
             }
-            catch { }
-        }
-        else {
-            const localPath = path.join(home, ".local", "bin", "agy");
-            if (fs.existsSync(localPath))
-                return localPath;
         }
     }
-    return "agy";
+    cachedBinaryPath = resolved;
+    lastBinaryResolveTime = now;
+    return resolved;
 }
 export class AntigravityProcess extends EventEmitter {
     child = null;
@@ -123,6 +189,13 @@ export class AntigravityProcess extends EventEmitter {
             this.scheduleRestart();
         }
     }
+    get currentPermissions() {
+        return this.permissions;
+    }
+    setPermissions(permissions) {
+        this.permissions = { ...this.permissions, ...permissions };
+        this.scheduleRestart();
+    }
     setConversationId(conversationId) {
         if (this.conversationId !== conversationId) {
             this.conversationId = conversationId;
@@ -282,12 +355,13 @@ export class AntigravityProcess extends EventEmitter {
             effectiveEffort,
         });
         const isWin = process.platform === "win32";
+        const isBatch = isWin && isWindowsBatchScript(this.binaryPath);
         const child = spawn(this.binaryPath, args, {
             cwd: this.cwd,
             env: this.env,
             stdio: ["pipe", "pipe", "pipe"],
             detached: !isWin,
-            shell: isWin,
+            shell: isBatch,
             windowsHide: true,
         });
         this.child = child;

package/dist/asar.d.ts

@@ -0,0 +1,28 @@
+export interface AsarNode {
+    files?: Record<string, AsarNode>;
+    size?: number;
+    offset?: string;
+    executable?: boolean;
+    unpacked?: boolean;
+}
+/**
+ * Reads and parses the ASAR archive header and returns the root node and base offset for data.
+ */
+export declare function readArchiveHeader(archivePath: string): {
+    header: AsarNode;
+    dataBaseOffset: number;
+};
+/**
+ * Lists all file paths inside an ASAR archive.
+ */
+export declare function listPackage(archivePath: string): string[];
+/**
+ * Pure TypeScript, zero-dependency ASAR archive extractor.
+ * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
+ */
+export declare function extractAll(archivePath: string, destDir: string): void;
+/**
+ * Pure TypeScript, zero-dependency ASAR archive builder.
+ * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
+ */
+export declare function createPackage(srcDir: string, destFile: string): Promise<void>;

package/dist/asar.js

@@ -0,0 +1,171 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Reads and parses the ASAR archive header and returns the root node and base offset for data.
+ */
+export function readArchiveHeader(archivePath) {
+    if (!fs.existsSync(archivePath)) {
+        throw new Error(`ASAR archive not found: ${archivePath}`);
+    }
+    const fd = fs.openSync(archivePath, "r");
+    try {
+        const sizeBuf = Buffer.alloc(8);
+        const bytesRead = fs.readSync(fd, sizeBuf, 0, 8, 0);
+        if (bytesRead < 8) {
+            throw new Error(`Invalid ASAR archive: file too small (${bytesRead} bytes)`);
+        }
+        const payloadSize = sizeBuf.readUInt32LE(0);
+        const headerSize = sizeBuf.readUInt32LE(4);
+        if (payloadSize !== 4 || headerSize <= 0) {
+            throw new Error(`Invalid ASAR archive header size: payloadSize=${payloadSize}, headerSize=${headerSize}`);
+        }
+        const headerPickleBuf = Buffer.alloc(headerSize);
+        const headerRead = fs.readSync(fd, headerPickleBuf, 0, headerSize, 8);
+        if (headerRead < headerSize) {
+            throw new Error(`Truncated ASAR header: expected ${headerSize} bytes, got ${headerRead}`);
+        }
+        const strLen = headerPickleBuf.readUInt32LE(4);
+        const jsonStr = headerPickleBuf.subarray(8, 8 + strLen).toString("utf8");
+        const header = JSON.parse(jsonStr);
+        const dataBaseOffset = 8 + headerSize;
+        return { header, dataBaseOffset };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Lists all file paths inside an ASAR archive.
+ */
+export function listPackage(archivePath) {
+    const { header } = readArchiveHeader(archivePath);
+    const result = [];
+    function walk(node, currentPrefix) {
+        if (node.files) {
+            for (const [name, child] of Object.entries(node.files)) {
+                const next = currentPrefix ? `${currentPrefix}/${name}` : `/${name}`;
+                walk(child, next);
+            }
+        }
+        else {
+            result.push(currentPrefix);
+        }
+    }
+    walk(header, "");
+    return result;
+}
+/**
+ * Pure TypeScript, zero-dependency ASAR archive extractor.
+ * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
+ */
+export function extractAll(archivePath, destDir) {
+    const { header, dataBaseOffset } = readArchiveHeader(archivePath);
+    const fd = fs.openSync(archivePath, "r");
+    try {
+        function extractNode(node, currentPath, relParts = []) {
+            if (node.files) {
+                fs.mkdirSync(currentPath, { recursive: true });
+                for (const [name, child] of Object.entries(node.files)) {
+                    extractNode(child, path.join(currentPath, name), [...relParts, name]);
+                }
+            }
+            else if (node.size !== undefined && node.offset !== undefined) {
+                const fileOffset = dataBaseOffset + parseInt(node.offset, 10);
+                const fileBuf = Buffer.alloc(node.size);
+                if (node.size > 0) {
+                    fs.readSync(fd, fileBuf, 0, node.size, fileOffset);
+                }
+                fs.mkdirSync(path.dirname(currentPath), { recursive: true });
+                fs.writeFileSync(currentPath, fileBuf, {
+                    mode: node.executable ? 0o755 : 0o644,
+                });
+            }
+            else if (node.unpacked) {
+                const unpackedSrc = path.join(archivePath + ".unpacked", ...relParts);
+                if (fs.existsSync(unpackedSrc)) {
+                    fs.mkdirSync(path.dirname(currentPath), { recursive: true });
+                    fs.copyFileSync(unpackedSrc, currentPath);
+                }
+            }
+        }
+        extractNode(header, destDir);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Pure TypeScript, zero-dependency ASAR archive builder.
+ * Compatible with all Node.js versions (Node 18, 20, 22, 24+) across Windows, macOS, and Linux.
+ */
+export async function createPackage(srcDir, destFile) {
+    const files = [];
+    function walk(dir, rel = "") {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        for (const e of entries) {
+            const entryRel = rel ? `${rel}/${e.name}` : e.name;
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) {
+                walk(full, entryRel);
+            }
+            else if (e.isFile()) {
+                const stat = fs.statSync(full);
+                const executable = Boolean(stat.mode & 0o111);
+                files.push({
+                    relPath: entryRel,
+                    fullPath: full,
+                    size: stat.size,
+                    executable: executable || undefined,
+                });
+            }
+        }
+    }
+    walk(srcDir);
+    const header = { files: {} };
+    let currentOffset = 0;
+    for (const f of files) {
+        const parts = f.relPath.split("/");
+        let curr = header.files;
+        for (let i = 0; i < parts.length - 1; i++) {
+            if (!curr[parts[i]]) {
+                curr[parts[i]] = { files: {} };
+            }
+            curr = curr[parts[i]].files;
+        }
+        const leaf = parts[parts.length - 1];
+        curr[leaf] = {
+            size: f.size,
+            offset: String(currentOffset),
+            executable: f.executable,
+        };
+        currentOffset += f.size;
+    }
+    const jsonBuf = Buffer.from(JSON.stringify(header), "utf8");
+    const alignedJsonLen = (jsonBuf.length + 3) & ~3;
+    const headerPayloadSize = 4 + alignedJsonLen;
+    // Header pickle: payloadSize (uint32LE) + stringLength (uint32LE) + json bytes (padded to multiple of 4)
+    const headerPickle = Buffer.alloc(4 + headerPayloadSize, 0);
+    headerPickle.writeUInt32LE(headerPayloadSize, 0);
+    headerPickle.writeUInt32LE(jsonBuf.length, 4);
+    jsonBuf.copy(headerPickle, 8);
+    // Size pickle: 4 (uint32LE payload size) + headerPickle.length (uint32LE)
+    const sizePickle = Buffer.alloc(8, 0);
+    sizePickle.writeUInt32LE(4, 0);
+    sizePickle.writeUInt32LE(headerPickle.length, 4);
+    fs.mkdirSync(path.dirname(destFile), { recursive: true });
+    const fd = fs.openSync(destFile, "w");
+    try {
+        fs.writeSync(fd, sizePickle);
+        fs.writeSync(fd, headerPickle);
+        for (const f of files) {
+            if (f.size > 0) {
+                const content = fs.readFileSync(f.fullPath);
+                fs.writeSync(fd, content);
+            }
+        }
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}

package/dist/attachments.js

@@ -7,6 +7,9 @@ const DEFAULT_MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
 function getStateRoot() {
     if (process.env.AGY_ACP_STATE_DIR)
         return process.env.AGY_ACP_STATE_DIR;
+    if (process.platform === "win32" && process.env.LOCALAPPDATA) {
+        return path.join(process.env.LOCALAPPDATA, "agy-acp");
+    }
     const stateHome = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
     return path.join(stateHome, "agy-acp");
 }