viberoom 0.3.0 → 0.4.0

package/vendor/acp/claude-agent-acp/dist/file-change-audit.js

@@ -0,0 +1,350 @@
+import { createSdkMcpServer, } from "../../claude-agent-sdk/sdk.mjs";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { z } from "zod";
+import { airExtensionMeta, clientSupportsAirCapability, withAirMeta } from "./air-extension.js";
+export const AGENT_FILE_CHANGE_REPORT_CAPABILITY = "agentFileChangeReport";
+export const FILE_CHANGE_AUDIT_SERVER_NAME = "claude_agent_acp";
+export const FILE_CHANGE_AUDIT_TOOL_NAME = "report_changed_files";
+export const FILE_CHANGE_AUDIT_WIRE_TOOL_NAME = `mcp__${FILE_CHANGE_AUDIT_SERVER_NAME}__${FILE_CHANGE_AUDIT_TOOL_NAME}`;
+const FILE_CHANGE_AUDIT_MARKER = "claude-agent-acp-file-change-audit";
+const MAX_REPORTED_PATHS = 1024;
+const MAX_REPORTED_PATH_LENGTH = 4096;
+export const AGENT_FILE_CHANGE_REPORT_MAX_BYTES = 256 * 1024;
+const REQUEST_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
+const reportInputSchema = {
+    paths: z
+        .array(z.string())
+        .describe("Workspace file paths changed during this turn. Use absolute paths or paths relative to cwd."),
+    complete: z
+        .boolean()
+        .describe("True only when paths contains every workspace file changed during this turn."),
+    uncertainty: z
+        .string()
+        .trim()
+        .min(1)
+        .max(2000)
+        .optional()
+        .describe("Why the report may be incomplete or uncertain."),
+};
+export function agentFileChangeReportRequestId(meta) {
+    const air = airExtensionMeta(meta);
+    const request = air?.agentFileChangeReportRequest;
+    if (!request || typeof request !== "object" || Array.isArray(request))
+        return undefined;
+    const requestRecord = request;
+    const requestKeys = Object.keys(requestRecord);
+    if (requestKeys.length !== 2 ||
+        !requestKeys.includes("version") ||
+        !requestKeys.includes("requestId") ||
+        requestRecord.version !== 1)
+        return undefined;
+    const requestId = requestRecord.requestId;
+    return typeof requestId === "string" && REQUEST_ID_PATTERN.test(requestId)
+        ? requestId
+        : undefined;
+}
+export function supportsAgentFileChangeReport(capabilities) {
+    return clientSupportsAirCapability(capabilities, AGENT_FILE_CHANGE_REPORT_CAPABILITY);
+}
+export function agentFileChangeReportMeta(result) {
+    return withAirMeta(undefined, AGENT_FILE_CHANGE_REPORT_CAPABILITY, result);
+}
+export function createFileChangeAuditTurnState(requestId) {
+    return {
+        requestId,
+        phase: "requested",
+    };
+}
+export function isFileChangeAuditReportPhase(state) {
+    return state?.phase === "collecting" || state?.phase === "finished";
+}
+export function isFileChangeAuditTool(toolName) {
+    return toolName === FILE_CHANGE_AUDIT_WIRE_TOOL_NAME;
+}
+export function containsFileChangeAuditMarker(text) {
+    return text.includes(`<${FILE_CHANGE_AUDIT_MARKER}>`);
+}
+export function createFileChangeAuditSupport(options) {
+    const workspace = normalizeWorkspace(options.cwd, options.additionalDirectories);
+    const finishUnavailable = async (state, reason) => {
+        // Claim the terminal outcome before the first await. The report tool, a
+        // Stop hook, cancellation, and stream teardown can race, but only the
+        // winner may publish for this request id. Publication remains fail-open:
+        // an audit transport failure must never hold the user prompt open.
+        if (state.phase === "finished")
+            return;
+        state.phase = "finished";
+        try {
+            await options.publish({
+                version: 1,
+                requestId: state.requestId,
+                status: "unavailable",
+                reason,
+            });
+        }
+        catch (error) {
+            options.logError(`Failed to publish unavailable report ${state.requestId}: ${error}`);
+        }
+    };
+    const tool = {
+        name: FILE_CHANGE_AUDIT_TOOL_NAME,
+        description: "Internal audit tool. Call it only when a stop-hook message explicitly requests the file-change audit.",
+        inputSchema: reportInputSchema,
+        _meta: {
+            "anthropic/alwaysLoad": true,
+            "claude/endTurn": true,
+        },
+        handler: async (report) => {
+            const state = options.getActiveState();
+            if (!state || state.phase !== "collecting") {
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: `<${FILE_CHANGE_AUDIT_MARKER}>No file-change audit is active.</${FILE_CHANGE_AUDIT_MARKER}>`,
+                        },
+                    ],
+                };
+            }
+            // Flip before publishing: a client transport failure must not make the
+            // model retry the report and produce duplicates. Delivery is audit-only
+            // and fail-open; the normal turn must still finish.
+            state.phase = "finished";
+            const normalized = normalizeReportedPaths(report.paths, workspace);
+            const result = fitReportedAgentFileChangeReport({
+                version: 1,
+                requestId: state.requestId,
+                status: "reported",
+                paths: normalized.paths,
+                declaredComplete: report.complete && !normalized.truncated,
+                truncated: normalized.truncated,
+                ...(report.uncertainty ? { uncertainty: report.uncertainty } : {}),
+            });
+            try {
+                await options.publish(result);
+            }
+            catch (error) {
+                options.logError(`Failed to publish file-change report ${state.requestId}: ${error}`);
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `<${FILE_CHANGE_AUDIT_MARKER}>File-change audit recorded.</${FILE_CHANGE_AUDIT_MARKER}>`,
+                    },
+                ],
+                structuredContent: result,
+            };
+        },
+    };
+    // canUseTool is not guaranteed to run for tools that the current permission
+    // mode auto-allows (notably bypassPermissions). A PreToolUse hook is the
+    // enforcement boundary that keeps the hidden continuation read-only in every
+    // mode: it can submit the report, but cannot inspect or mutate more files.
+    const preToolUseHook = async (input) => {
+        if (input.hook_event_name !== "PreToolUse")
+            return {};
+        const state = options.getActiveState();
+        const isReportTool = isFileChangeAuditTool(input.tool_name);
+        if (!isReportTool && !isFileChangeAuditReportPhase(state))
+            return {};
+        const allowReport = state?.phase === "collecting" && isReportTool;
+        return {
+            hookSpecificOutput: {
+                hookEventName: "PreToolUse",
+                permissionDecision: allowReport ? "allow" : "deny",
+                ...(!allowReport
+                    ? {
+                        permissionDecisionReason: "Only the internal file-change report is allowed during the audit.",
+                    }
+                    : {}),
+            },
+        };
+    };
+    const stopHook = async (input) => {
+        if (input.hook_event_name !== "Stop")
+            return {};
+        const state = options.getActiveState();
+        if (!state || state.phase === "finished")
+            return {};
+        // A Stop can be only a pause while a background generator is still
+        // running. Keep the request pending so a later final Stop can include its
+        // writes instead of declaring a prematurely complete path set.
+        if (state.phase === "requested" && (input.background_tasks?.length ?? 0) > 0)
+            return {};
+        if (state.phase === "collecting" || input.stop_hook_active) {
+            await finishUnavailable(state, "notReported");
+            return {};
+        }
+        // Set the phase before returning the continuation so every following SDK
+        // message is hidden even if the next stream starts immediately.
+        state.phase = "collecting";
+        return {
+            hookSpecificOutput: {
+                hookEventName: "Stop",
+                additionalContext: `<${FILE_CHANGE_AUDIT_MARKER}>` +
+                    `Before stopping, call ${FILE_CHANGE_AUDIT_WIRE_TOOL_NAME} exactly once. ` +
+                    "Report every workspace file changed during this user turn, including files changed " +
+                    "by commands, generators, version-control operations, and child processes. " +
+                    "Do not call any other tool and do not emit user-facing prose. " +
+                    "Set complete to false and explain uncertainty when you are not sure the list is complete." +
+                    `</${FILE_CHANGE_AUDIT_MARKER}>`,
+            },
+        };
+    };
+    return {
+        mcpServer: createSdkMcpServer({
+            name: FILE_CHANGE_AUDIT_SERVER_NAME,
+            version: "1.0.0",
+            tools: [tool],
+            alwaysLoad: true,
+        }),
+        preToolUseHook,
+        stopHook,
+        finishUnavailable,
+    };
+}
+function normalizeWorkspace(cwd, additionalDirectories) {
+    const normalizedCwd = canonicalizeWorkspaceRoot(path.resolve(cwd));
+    const seen = new Set([pathKey(normalizedCwd)]);
+    const normalizedAdditionalDirectories = [];
+    for (const directory of additionalDirectories) {
+        const normalized = canonicalizeWorkspaceRoot(path.resolve(normalizedCwd, directory));
+        const key = pathKey(normalized);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        normalizedAdditionalDirectories.push(normalized);
+    }
+    return {
+        cwd: normalizedCwd,
+        additionalDirectories: normalizedAdditionalDirectories,
+    };
+}
+function normalizeReportedPaths(reportedPaths, workspace) {
+    const roots = [workspace.cwd, ...workspace.additionalDirectories];
+    const seen = new Set();
+    const result = [];
+    let totalBytes = 0;
+    let truncated = false;
+    for (const reportedPath of reportedPaths) {
+        if (reportedPath.trim().length === 0 ||
+            reportedPath.length > MAX_REPORTED_PATH_LENGTH ||
+            hasControlCharacter(reportedPath)) {
+            truncated = true;
+            continue;
+        }
+        let normalized;
+        try {
+            normalized = canonicalizeReportedPath(path.resolve(workspace.cwd, reportedPath));
+        }
+        catch {
+            truncated = true;
+            continue;
+        }
+        if (normalized.length > MAX_REPORTED_PATH_LENGTH || hasControlCharacter(normalized)) {
+            truncated = true;
+            continue;
+        }
+        if (!roots.some((root) => isWithinRoot(normalized, root))) {
+            truncated = true;
+            continue;
+        }
+        const key = pathKey(normalized);
+        if (roots.some((root) => pathKey(root) === key)) {
+            truncated = true;
+            continue;
+        }
+        if (seen.has(key)) {
+            continue;
+        }
+        const pathBytes = Buffer.byteLength(normalized, "utf8");
+        if (result.length >= MAX_REPORTED_PATHS ||
+            totalBytes + pathBytes > AGENT_FILE_CHANGE_REPORT_MAX_BYTES) {
+            truncated = true;
+            continue;
+        }
+        seen.add(key);
+        result.push(normalized);
+        totalBytes += pathBytes;
+    }
+    return { paths: result, truncated };
+}
+/** Keep the complete serialized report within AIR's wire limit. */
+function fitReportedAgentFileChangeReport(report) {
+    const paths = [...report.paths];
+    let fitted = report;
+    while (Buffer.byteLength(JSON.stringify(fitted), "utf8") > AGENT_FILE_CHANGE_REPORT_MAX_BYTES) {
+        if (paths.length === 0) {
+            // The fixed fields and bounded uncertainty are far below the cap. Keep
+            // this loud if the wire contract changes without updating this helper.
+            throw new Error("Agent file-change report exceeds the wire limit without paths");
+        }
+        paths.pop();
+        fitted = {
+            ...report,
+            paths: [...paths],
+            declaredComplete: false,
+            truncated: true,
+        };
+    }
+    return fitted;
+}
+function isWithinRoot(candidate, root) {
+    const relative = path.relative(root, candidate);
+    return !path.isAbsolute(relative) && !relative.startsWith(`..${path.sep}`) && relative !== "..";
+}
+/**
+ * Resolve filesystem aliases in a workspace root, including macOS' /tmp ->
+ * /private/tmp alias. For a root that does not exist yet, resolve its nearest
+ * existing ancestor and retain the missing suffix.
+ */
+function canonicalizeWorkspaceRoot(value) {
+    return canonicalizeFromExistingAncestor(value);
+}
+/**
+ * Canonicalize the parent but not the leaf itself. A changed path may be
+ * deleted, or it may be a symlink whose node (rather than target) changed.
+ */
+function canonicalizeReportedPath(value) {
+    const parent = canonicalizeFromExistingAncestor(path.dirname(value));
+    return path.resolve(parent, path.basename(value));
+}
+function canonicalizeFromExistingAncestor(value) {
+    const original = path.resolve(value);
+    let current = original;
+    const missingSegments = [];
+    while (true) {
+        try {
+            const canonical = fs.realpathSync.native(current);
+            return path.resolve(canonical, ...missingSegments.reverse());
+        }
+        catch (error) {
+            if (!isMissingPathError(error))
+                return original;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return original;
+        missingSegments.push(path.basename(current));
+        current = parent;
+    }
+}
+function isMissingPathError(error) {
+    if (typeof error !== "object" || error === null || !("code" in error))
+        return false;
+    return error.code === "ENOENT" || error.code === "ENOTDIR";
+}
+function pathKey(value) {
+    return process.platform === "win32" ? value.toLowerCase() : value;
+}
+function hasControlCharacter(value) {
+    for (let index = 0; index < value.length; index++) {
+        const code = value.charCodeAt(index);
+        if (code <= 0x1f || (code >= 0x7f && code <= 0x9f))
+            return true;
+    }
+    return false;
+}

package/vendor/acp/claude-agent-acp/dist/fork-session.js

@@ -0,0 +1,41 @@
+import { RequestError } from "@agentclientprotocol/sdk";
+import { forkSession as forkClaudeSession, getSessionMessages, } from "../../claude-agent-sdk/sdk.mjs";
+function forkPointMessageId(meta) {
+    const fork = meta?.jetbrains?.air?.fork;
+    if (fork?.version !== 1)
+        return undefined;
+    const messageId = fork.messageId?.trim();
+    return messageId || undefined;
+}
+function forkPointMessageIdCandidates(messageId) {
+    // Older AIR builds sent their visible segment id. Prefer the exact id before its ACP source id.
+    const protocolMessageId = messageId.replace(/:segment:\d+$/, "");
+    return protocolMessageId === messageId ? [messageId] : [messageId, protocolMessageId];
+}
+export async function forkSession(params, dependencies) {
+    const messageId = forkPointMessageId(params._meta);
+    if (!messageId) {
+        const forked = await forkClaudeSession(params.sessionId, { dir: params.cwd });
+        return { sessionId: forked.sessionId };
+    }
+    const candidateIds = forkPointMessageIdCandidates(messageId);
+    const liveUuid = candidateIds
+        .map((candidateId) => dependencies.liveMessageIdToUuid?.get(candidateId))
+        .find(Boolean);
+    const history = liveUuid
+        ? undefined
+        : await getSessionMessages(params.sessionId, { dir: params.cwd });
+    const messageUuid = liveUuid ??
+        candidateIds
+            .map((candidateId) => history?.find((message) => dependencies.messageIdForGrouping(message) === candidateId)
+            ?.uuid)
+            .find(Boolean);
+    if (!messageUuid) {
+        throw RequestError.invalidParams({ messageId }, `Fork point message ${messageId} was not found in session ${params.sessionId}`);
+    }
+    const forked = await forkClaudeSession(params.sessionId, {
+        dir: params.cwd,
+        upToMessageId: messageUuid,
+    });
+    return { sessionId: forked.sessionId };
+}

package/vendor/acp/claude-agent-acp/dist/goal-extension.js

@@ -0,0 +1,50 @@
+import { RequestError } from "@agentclientprotocol/sdk";
+export const GOAL_EXTENSION_VERSION = 1;
+export const GOAL_CONTROL_METHOD = "_session/goal";
+export const GOAL_ACTIONS = ["set", "clear"];
+export function goalUpdateFromPrompt(prompt) {
+    const match = /^\/goal(?:\s+([\s\S]*))?$/.exec(prompt);
+    const argument = match?.[1]?.trim();
+    if (!argument) {
+        return undefined;
+    }
+    if (argument === "clear") {
+        return null;
+    }
+    return {
+        objective: argument,
+        status: "active",
+        controlMethod: GOAL_CONTROL_METHOD,
+    };
+}
+export function parseGoalRequest(params) {
+    if (!params || typeof params !== "object") {
+        throw RequestError.invalidParams(undefined, "goal params must be an object");
+    }
+    const { sessionId, action, objective } = params;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+        throw RequestError.invalidParams(undefined, "goal params require a non-empty sessionId");
+    }
+    if (!GOAL_ACTIONS.includes(action)) {
+        throw RequestError.invalidParams(undefined, 'goal action must be "set" or "clear"');
+    }
+    if (action === "set" && (typeof objective !== "string" || objective.trim().length === 0)) {
+        throw RequestError.invalidParams(undefined, 'goal action "set" requires a non-empty objective');
+    }
+    return action === "set"
+        ? { sessionId, action, objective: objective.trim() }
+        : { sessionId, action: "clear" };
+}
+export function toGoalSnapshot(message) {
+    if (message.value === null) {
+        return null;
+    }
+    return {
+        objective: message.value.condition.trim(),
+        status: "active",
+        iterations: message.value.iterations,
+        lastReason: message.value.last_reason ?? null,
+        createdAt: message.value.set_at,
+        controlMethod: GOAL_CONTROL_METHOD,
+    };
+}

package/vendor/acp/claude-agent-acp/dist/index.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { resolveSettings } from "../../claude-agent-sdk/sdk.mjs";
+import { claudeCliPath, runAcp } from "./acp-agent.js";
+import packageJson from "../package.json" with { type: "json" };
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+// `--cli` is checked first so that `--version`/`-v` (and any other flags) are
+// forwarded to the wrapped native CLI rather than swallowed by our own version
+// handler below. Our version flag only applies when not delegating.
+if (process.argv.includes("--cli")) {
+    const { spawn } = await import("node:child_process");
+    const args = process.argv.slice(2).filter((arg) => arg !== "--cli");
+    const child = spawn(await claudeCliPath(), args, { stdio: "inherit" });
+    const signals = process.platform === "win32"
+        ? ["SIGINT", "SIGTERM"]
+        : ["SIGINT", "SIGTERM", "SIGHUP"];
+    for (const sig of signals) {
+        process.on(sig, () => {
+            if (!child.killed)
+                child.kill(sig);
+        });
+    }
+    child.on("exit", (code, signal) => {
+        if (signal && process.platform !== "win32") {
+            // Remove our listener so re-raising actually terminates instead of
+            // re-entering the no-op handler, which would let us exit with code 0
+            // instead of the signal's conventional 128+N.
+            process.removeAllListeners(signal);
+            process.kill(process.pid, signal);
+        }
+        else {
+            process.exit(code ?? 1);
+        }
+    });
+    child.on("error", (err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}
+else if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    console.log(packageJson.version);
+    process.exit(0);
+}
+else {
+    // Apply env vars from the managed-policy tier before any SDK call so the
+    // SDK subprocess inherits them. Going through resolveSettings (vs. a raw
+    // read of managed-settings.json) also picks up MDM sources on macOS and
+    // HKLM/HKCU on Windows.
+    const policy = await resolveSettings({ settingSources: [] });
+    for (const [key, value] of Object.entries(policy.effective.env ?? {})) {
+        process.env[key] = value;
+    }
+    // stdout is used to send messages to the client
+    // we redirect everything else to stderr to make sure it doesn't interfere with ACP
+    console.log = console.error;
+    console.info = console.error;
+    console.warn = console.error;
+    console.debug = console.error;
+    process.on("unhandledRejection", (reason, promise) => {
+        console.error("Unhandled Rejection at:", promise, "reason:", reason);
+    });
+    const logDirectory = process.env.CLAUDE_AGENT_LOGS;
+    const logger = logDirectory
+        ? (() => {
+            mkdirSync(logDirectory, { recursive: true });
+            const logFile = join(logDirectory, "agent.log");
+            const writeLog = (...args) => {
+                const rendered = args
+                    .map((arg) => (arg instanceof Error ? (arg.stack ?? arg.message) : String(arg)))
+                    .join(" ");
+                appendFileSync(logFile, `${new Date().toISOString()} pid=${process.pid} ${rendered}\n`);
+            };
+            return {
+                log: writeLog,
+                error: (...args) => {
+                    console.error(...args);
+                    writeLog(...args);
+                },
+            };
+        })()
+        : undefined;
+    logger?.log("Claude ACP started");
+    const { connection, agent } = runAcp(logger);
+    async function shutdown() {
+        await agent.dispose().catch((err) => {
+            console.error("Error during cleanup:", err);
+        });
+        process.exit(0);
+    }
+    // Exit cleanly when the ACP connection closes (e.g. stdin EOF, transport
+    // error). Without this, `process.stdin.resume()` keeps the event loop
+    // alive indefinitely, causing orphan process accumulation in oneshot mode.
+    connection.closed.then(shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    // Keep process alive while connection is open
+    process.stdin.resume();
+}

package/vendor/acp/claude-agent-acp/dist/lib.js

@@ -0,0 +1,5 @@
+// Export the main agent class and utilities for library usage
+export { ClaudeAcpAgent, isLocalCommandMetadata, stripLocalCommandMetadata, runAcp, toAcpNotifications, streamEventToAcpNotifications, } from "./acp-agent.js";
+export { nodeToWebReadable, nodeToWebWritable, Pushable, unreachable } from "./utils.js";
+export { toolInfoFromToolUse, toDisplayPath, planEntries, toolUpdateFromToolResult, } from "./tools.js";
+export { SettingsManager } from "./settings.js";