paseo-acp-agy 1.1.0

package/dist/logger.d.ts

@@ -0,0 +1,19 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export declare function sanitizeString(str: string): string;
+export declare function sanitize(data: unknown): unknown;
+export declare class Logger {
+    logFilePath: string;
+    private minLevel;
+    private writeStream;
+    constructor(options?: {
+        minLevel?: LogLevel;
+        logDir?: string;
+    });
+    private log;
+    debug(message: string, meta?: unknown): void;
+    info(message: string, meta?: unknown): void;
+    warn(message: string, meta?: unknown): void;
+    error(message: string, meta?: unknown): void;
+    close(): void;
+}
+export declare const logger: Logger;

package/dist/logger.js

@@ -0,0 +1,124 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+const LOG_LEVELS = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+function getLogDir() {
+    if (process.env.AGY_ACP_LOG_DIR) {
+        return process.env.AGY_ACP_LOG_DIR;
+    }
+    const stateHome = process.env.XDG_STATE_HOME || path.join(os.homedir(), ".local", "state");
+    return path.join(stateHome, "agy-acp");
+}
+function resolveLogLevel() {
+    const envLevel = process.env.AGY_ACP_LOG_LEVEL?.toLowerCase();
+    if (envLevel === "debug" || envLevel === "info" || envLevel === "warn" || envLevel === "error") {
+        return envLevel;
+    }
+    return "info";
+}
+export function sanitizeString(str) {
+    return str
+        .replace(/(Bearer\s+)[a-zA-Z0-9_\-\.]{8,}/gi, "$1[REDACTED]")
+        .replace(/(token|key|secret|password|auth|authorization|api[_-]?key)(\s*[:=]\s*['"]?)[a-zA-Z0-9_\-\.]{6,}(['"]?)/gi, "$1$2[REDACTED]$3")
+        .replace(/AIza[0-9A-Za-z-_]{35}/g, "[REDACTED_API_KEY]")
+        .replace(/ya29\.[0-9A-Za-z-_]+/g, "[REDACTED_OAUTH_TOKEN]");
+}
+export function sanitize(data) {
+    if (typeof data === "string") {
+        return sanitizeString(data);
+    }
+    if (data && typeof data === "object") {
+        if (Array.isArray(data)) {
+            return data.map(sanitize);
+        }
+        const clean = {};
+        for (const [k, v] of Object.entries(data)) {
+            if (/token|secret|password|auth|cookie|credential|authorization|api[_-]?key/i.test(k)) {
+                clean[k] = typeof v === "object" && v !== null ? sanitize(v) : "[REDACTED]";
+            }
+            else {
+                clean[k] = sanitize(v);
+            }
+        }
+        return clean;
+    }
+    return data;
+}
+export class Logger {
+    logFilePath;
+    minLevel;
+    writeStream = null;
+    constructor(options) {
+        this.minLevel = options?.minLevel || resolveLogLevel();
+        const dir = options?.logDir || getLogDir();
+        try {
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+            try {
+                fs.chmodSync(dir, 0o700);
+            }
+            catch { }
+        }
+        catch { }
+        this.logFilePath = path.join(dir, "agy-acp.log");
+        try {
+            if (!fs.existsSync(this.logFilePath)) {
+                fs.writeFileSync(this.logFilePath, "", { mode: 0o600 });
+            }
+            else {
+                try {
+                    fs.chmodSync(this.logFilePath, 0o600);
+                }
+                catch { }
+            }
+            this.writeStream = fs.createWriteStream(this.logFilePath, { flags: "a", mode: 0o600 });
+            this.writeStream.on("error", () => { });
+        }
+        catch {
+            this.writeStream = null;
+        }
+    }
+    log(level, message, meta) {
+        if (LOG_LEVELS[level] < LOG_LEVELS[this.minLevel]) {
+            return;
+        }
+        const timestamp = new Date().toISOString();
+        const sanitizedMeta = meta !== undefined ? sanitize(meta) : undefined;
+        const entry = {
+            timestamp,
+            level,
+            message: sanitizeString(message),
+            ...(sanitizedMeta !== undefined ? { data: sanitizedMeta } : {}),
+        };
+        const line = JSON.stringify(entry) + "\n";
+        if (this.writeStream) {
+            this.writeStream.write(line);
+        }
+        if (process.env.AGY_ACP_STDERR_LOG === "true" || process.env.AGY_ACP_STDERR_LOG === "1") {
+            process.stderr.write(`[agy-acp] ${timestamp} [${level.toUpperCase()}] ${entry.message} ${meta ? JSON.stringify(sanitizedMeta) : ""}\n`);
+        }
+    }
+    debug(message, meta) {
+        this.log("debug", message, meta);
+    }
+    info(message, meta) {
+        this.log("info", message, meta);
+    }
+    warn(message, meta) {
+        this.log("warn", message, meta);
+    }
+    error(message, meta) {
+        this.log("error", message, meta);
+    }
+    close() {
+        if (this.writeStream) {
+            this.writeStream.end();
+            this.writeStream = null;
+        }
+    }
+}
+export const logger = new Logger();

package/dist/permissions.d.ts

@@ -0,0 +1,11 @@
+export interface PermissionSettings {
+    sandbox: boolean;
+    dangerouslySkipPermissions: boolean;
+    mode?: string;
+}
+export declare function resolvePermissionSettings(options?: {
+    sandbox?: boolean;
+    dangerouslySkipPermissions?: boolean;
+    mode?: string;
+}): PermissionSettings;
+export declare function buildAgyArgs(settings: PermissionSettings, extraArgs?: string[]): string[];

package/dist/permissions.js

@@ -0,0 +1,29 @@
+// Permission and security settings for Antigravity ACP adapter
+export function resolvePermissionSettings(options) {
+    const envSandbox = process.env.AGY_ACP_SANDBOX;
+    const envSkipPerms = process.env.AGY_ACP_DANGEROUSLY_SKIP_PERMISSIONS;
+    const sandbox = options?.sandbox ?? (envSandbox === "true" || envSandbox === "1");
+    // Never default to skip permissions; must be explicit
+    const dangerouslySkipPermissions = options?.dangerouslySkipPermissions ?? (envSkipPerms === "true" || envSkipPerms === "1");
+    return {
+        sandbox,
+        dangerouslySkipPermissions,
+        mode: options?.mode,
+    };
+}
+export function buildAgyArgs(settings, extraArgs) {
+    const args = ["--input-format", "stream-json", "--output-format", "stream-json", "--print="];
+    if (settings.sandbox) {
+        args.push("--sandbox");
+    }
+    if (settings.dangerouslySkipPermissions) {
+        args.push("--dangerously-skip-permissions");
+    }
+    if (settings.mode && settings.mode !== "default") {
+        args.push("--mode", settings.mode);
+    }
+    if (extraArgs && extraArgs.length > 0) {
+        args.push(...extraArgs);
+    }
+    return args;
+}

package/dist/protocol.d.ts

@@ -0,0 +1,201 @@
+export interface AgyInitEvent {
+    event: "init";
+    conversation_id: string;
+    init: {
+        cwd?: string;
+        tools?: string[];
+        permission_mode?: string;
+        model?: string;
+        [key: string]: unknown;
+    };
+}
+export interface AgyStepUpdateEvent {
+    event: "step_update";
+    step_update: {
+        conversation_id: string;
+        step_index: number;
+        state: "ACTIVE" | "DONE" | "ERROR";
+        step_type: "user_input" | "agent_response" | "tool" | "thought" | string;
+        text_delta?: string;
+        duration_seconds?: number;
+        tool_name?: string;
+        tool_info?: {
+            name: string;
+            parameters?: Record<string, unknown>;
+            output?: string;
+            error?: {
+                type?: string;
+                message?: string;
+                [key: string]: unknown;
+            };
+            [key: string]: unknown;
+        };
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            thinking_tokens?: number;
+            cache_read_tokens?: number;
+            total_tokens?: number;
+        };
+        [key: string]: unknown;
+    };
+}
+export interface AgyResultEvent {
+    event: "result";
+    result: {
+        conversation_id: string;
+        status: "SUCCESS" | "ERROR";
+        response: string;
+        error?: string;
+        duration_seconds?: number;
+        num_turns?: number;
+        usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            thinking_tokens?: number;
+            cache_read_tokens?: number;
+            total_tokens?: number;
+        };
+        [key: string]: unknown;
+    };
+}
+export type AgyIncomingEvent = AgyInitEvent | AgyStepUpdateEvent | AgyResultEvent;
+export interface AgyStreamInputUserMessage {
+    event: "user";
+    message: {
+        content: string | Array<{
+            type: string;
+            text?: string;
+            [key: string]: unknown;
+        }>;
+    };
+}
+export type RequestId = string | number;
+export interface JsonRpcRequest<T = unknown> {
+    jsonrpc: "2.0";
+    id: RequestId;
+    method: string;
+    params?: T;
+}
+export interface JsonRpcNotification<T = unknown> {
+    jsonrpc: "2.0";
+    method: string;
+    params?: T;
+}
+export interface JsonRpcSuccessResponse<T = unknown> {
+    jsonrpc: "2.0";
+    id: RequestId;
+    result: T;
+}
+export interface JsonRpcErrorObject {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface JsonRpcErrorResponse {
+    jsonrpc: "2.0";
+    id: RequestId | null;
+    error: JsonRpcErrorObject;
+}
+export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcSuccessResponse | JsonRpcErrorResponse;
+export declare const ACP_METHODS: {
+    readonly INITIALIZE: "initialize";
+    readonly SESSION_NEW: "session/new";
+    readonly SESSION_NEW_ALIAS: "newSession";
+    readonly SESSION_LOAD: "session/load";
+    readonly SESSION_LOAD_ALIAS: "loadSession";
+    readonly SESSION_RESUME: "session/resume";
+    readonly SESSION_RESUME_ALIAS: "unstable_resumeSession";
+    readonly SESSION_PROMPT: "session/prompt";
+    readonly SESSION_PROMPT_ALIAS: "prompt";
+    readonly SESSION_CANCEL: "session/cancel";
+    readonly SESSION_CANCEL_ALIAS: "cancel";
+    readonly SESSION_CLOSE: "session/close";
+    readonly SESSION_CLOSE_ALIAS: "unstable_closeSession";
+    readonly SESSION_SET_MODE: "session/set_mode";
+    readonly SESSION_SET_MODE_ALIAS: "setSessionMode";
+    readonly SESSION_SET_MODEL: "session/set_model";
+    readonly SESSION_SET_MODEL_ALIAS: "unstable_setSessionModel";
+    readonly SESSION_SET_CONFIG_OPTION: "session/set_config_option";
+    readonly SESSION_SET_CONFIG_OPTION_ALIAS: "setSessionConfigOption";
+    readonly SESSION_UPDATE: "session/update";
+};
+export type ToolKind = "read" | "edit" | "execute" | "fetch" | "other";
+export declare function mapToolNameToKind(toolName: string): ToolKind;
+export declare function extractPromptText(promptInput: unknown): string;
+export interface ModelDefinition {
+    modelId: string;
+    name: string;
+    description?: string;
+    supportedEfforts: string[];
+    contextWindowMaxTokens?: number;
+}
+export interface ModelPricing {
+    inputCostPerM: number;
+    outputCostPerM: number;
+    cachedInputCostPerM: number;
+}
+export declare const MODEL_PRICING: Record<string, ModelPricing>;
+export declare const MODEL_CONTEXT_WINDOWS: Record<string, number>;
+export declare function getModelContextWindow(modelId?: string): number;
+export declare function getModelPricing(modelId?: string): ModelPricing | null;
+export declare function calculateUsageCostUsd(modelId?: string, inputTokens?: number, outputTokens?: number, cachedInputTokens?: number): number;
+export declare function roundUsageCostUsd(costUsd: number, decimals?: number): number;
+export interface QuotaWindow {
+    id: string;
+    label: string;
+    usedPct: number;
+    remainingPct: number;
+    resetsAt: string | null;
+    tone: "ok" | "warning" | "danger" | "default";
+}
+export declare function deriveUsageTone(usedPct: number): "ok" | "warning" | "danger" | "default";
+export declare function parseAgyQuotaOutput(raw: string): QuotaWindow[];
+export interface CreditsBalance {
+    id: string;
+    label: string;
+    remaining: number;
+    unit: "usd";
+    tone: "ok" | "warning" | "danger" | "default";
+}
+export declare function parseAgyCreditsOutput(raw: string): CreditsBalance;
+export interface ProviderUsage {
+    providerId: string;
+    displayName: string;
+    status: "available" | "unavailable";
+    planLabel: string | null;
+    windows: QuotaWindow[];
+    balances: CreditsBalance[];
+    details: Array<{
+        id: string;
+        label: string;
+        value: string;
+    }>;
+    error: string | null;
+}
+export declare function fetchAntigravityUsage(binaryPath?: string, force?: boolean): Promise<ProviderUsage>;
+export declare const ALL_THINKING_LEVELS: Record<string, {
+    name: string;
+    description: string;
+}>;
+export declare const FALLBACK_MODELS: ModelDefinition[];
+export declare function parseAgyModelsOutput(rawOutput: string): ModelDefinition[];
+export declare function fetchAvailableModels(binaryPath?: string, force?: boolean): Promise<ModelDefinition[]>;
+export declare function getEffectiveEffortForModel(modelId?: string, requestedEffort?: string, models?: ModelDefinition[]): string | undefined;
+export declare const AVAILABLE_MODES: {
+    id: string;
+    name: string;
+    description: string;
+}[];
+export declare function buildConfigOptionsForModel(modelId: string, currentEffort?: string, availableModels?: ModelDefinition[]): {
+    id: string;
+    name: string;
+    category: string;
+    type: "select";
+    currentValue: string;
+    options: {
+        value: string;
+        name: string;
+        description: string;
+    }[];
+}[];