@arcanemachine/inter-agent-opencode 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,47 @@
+export declare const DEFAULT_HOST = "127.0.0.1";
+export declare const DEFAULT_PORT = 16837;
+export declare const DEFAULT_TOKEN_FILENAME = "token";
+export declare const DEFAULT_TLS_CERT_FILENAME = "tls-cert.pem";
+export type Environment = Record<string, string | undefined>;
+export type ResolverOptions = {
+    env?: Environment;
+    platform?: NodeJS.Platform;
+    home?: string;
+};
+export type CoreConfig = Record<string, unknown>;
+export type LoadedConfig = {
+    values: CoreConfig;
+    path: string | undefined;
+};
+export type EndpointResolution = {
+    host: string;
+    port: number;
+    dataDir: string;
+    configPath: string | undefined;
+    hostSource: "env" | "config" | "default";
+    portSource: "env" | "config" | "default";
+    dataDirSource: "env" | "config" | "default";
+    tls: boolean;
+    tlsSource: "env" | "config" | "default";
+    scheme: "ws" | "wss";
+    tlsCertPath: string;
+    tlsCertSource: "env" | "config" | "default";
+    supported: boolean;
+    unsupportedReason?: string;
+};
+export type SecretResolution = {
+    secret: string;
+    source: "env" | "config" | "token_file";
+    tokenPath?: string;
+    configPath?: string;
+};
+export declare function expandPath(raw: string, options?: ResolverOptions): string;
+export declare function configPath(options?: ResolverOptions): string;
+export declare function dataDirectory(options?: ResolverOptions, config?: LoadedConfig): string;
+export declare function loadConfig(options?: ResolverOptions): LoadedConfig;
+export declare function resolvesLoopback(host: string): Promise<boolean>;
+export declare function resolveEndpoint(options?: ResolverOptions): Promise<EndpointResolution>;
+export declare function assertSupportedEndpoint(endpoint: EndpointResolution): void;
+export declare function tokenPath(options?: ResolverOptions, config?: LoadedConfig): string;
+export declare function endpointUri(endpoint: Pick<EndpointResolution, "host" | "port" | "scheme">): string;
+export declare function resolveSecret(options?: ResolverOptions, config?: LoadedConfig): SecretResolution;

package/dist/config.js

@@ -0,0 +1,349 @@
+import { randomBytes } from "node:crypto";
+import { lookup } from "node:dns/promises";
+import { chmodSync, closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { isIP } from "node:net";
+import { dirname, join } from "node:path";
+import { ConfigError, UnsupportedEndpointError } from "./errors.js";
+export const DEFAULT_HOST = "127.0.0.1";
+export const DEFAULT_PORT = 16837;
+export const DEFAULT_TOKEN_FILENAME = "token";
+export const DEFAULT_TLS_CERT_FILENAME = "tls-cert.pem";
+export function expandPath(raw, options = {}) {
+    const env = options.env ?? process.env;
+    const home = options.home ?? homedir();
+    let expanded = raw;
+    if (expanded === "~")
+        expanded = home;
+    else if (expanded.startsWith("~/"))
+        expanded = join(home, expanded.slice(2));
+    expanded = expanded.replace(/\$\{([^}]+)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g, (match, braced, plain) => {
+        const name = braced ?? plain;
+        return env[name] ?? match;
+    });
+    return expanded;
+}
+export function configPath(options = {}) {
+    const env = options.env ?? process.env;
+    const home = options.home ?? homedir();
+    const platform = options.platform ?? process.platform;
+    const override = env.INTER_AGENT_CONFIG;
+    if (override)
+        return expandPath(override, options);
+    if (platform === "darwin")
+        return join(home, "Library", "Application Support", "inter-agent", "config.json");
+    if (platform.startsWith("win")) {
+        const appData = env.APPDATA;
+        if (appData)
+            return join(appData, "inter-agent", "config.json");
+    }
+    const xdg = env.XDG_CONFIG_HOME;
+    if (xdg)
+        return join(xdg, "inter-agent", "config.json");
+    return join(home, ".config", "inter-agent", "config.json");
+}
+export function dataDirectory(options = {}, config) {
+    const env = options.env ?? process.env;
+    const home = options.home ?? homedir();
+    const platform = options.platform ?? process.platform;
+    if (env.INTER_AGENT_DATA_DIR)
+        return expandPath(env.INTER_AGENT_DATA_DIR, options);
+    const configured = configString(config?.values, "dataDir");
+    if (configured)
+        return expandPath(configured, options);
+    if (platform === "darwin")
+        return join(home, "Library", "Application Support", "inter-agent");
+    if (platform.startsWith("win")) {
+        const local = env.LOCALAPPDATA ?? env.APPDATA;
+        if (local)
+            return join(local, "inter-agent");
+    }
+    const xdg = env.XDG_STATE_HOME;
+    if (xdg)
+        return join(xdg, "inter-agent");
+    return join(home, ".local", "state", "inter-agent");
+}
+export function loadConfig(options = {}) {
+    const path = configPath(options);
+    if (!existsSync(path))
+        return { values: {}, path: undefined };
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        throw new ConfigError("invalid inter-agent config file");
+    }
+    if (!isRecord(parsed))
+        throw new ConfigError("inter-agent config root must be a JSON object");
+    return { values: parsed, path };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function configString(config, key) {
+    const value = config?.[key];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string")
+        throw new ConfigError(`inter-agent config key ${key} must be a string`);
+    return value;
+}
+function parsePort(value, source) {
+    if (typeof value === "number") {
+        if (!Number.isInteger(value))
+            throw new ConfigError(`${source} must be an integer`);
+        return validatePort(value, source);
+    }
+    if (typeof value !== "string" || !/^\d+$/.test(value))
+        throw new ConfigError(`${source} must be an integer`);
+    return validatePort(Number(value), source);
+}
+function validatePort(value, source) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > 65535) {
+        throw new ConfigError(`${source} must be between 1 and 65535`);
+    }
+    return value;
+}
+function envPort(env) {
+    const value = env.INTER_AGENT_PORT;
+    if (value === undefined || value === "")
+        return undefined;
+    return parsePort(value, "INTER_AGENT_PORT");
+}
+function parseBoolean(value, source) {
+    if (typeof value === "boolean")
+        return value;
+    if (typeof value !== "string")
+        throw new ConfigError(`${source} must be a boolean`);
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "on", "wss", "tls"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "off", "ws", "plaintext"].includes(normalized))
+        return false;
+    throw new ConfigError(`${source} must be a boolean`);
+}
+function configBoolean(config, key) {
+    const value = config[key];
+    if (value === undefined || value === null)
+        return undefined;
+    return parseBoolean(value, `inter-agent config key ${key}`);
+}
+function envBoolean(env, key) {
+    const value = env[key];
+    if (value === undefined || value === "")
+        return undefined;
+    return parseBoolean(value, key);
+}
+function normalizedHost(host) {
+    const trimmed = host.trim();
+    return trimmed.startsWith("[") && trimmed.endsWith("]")
+        ? trimmed.slice(1, -1)
+        : trimmed;
+}
+function isLoopbackIp(host) {
+    const value = normalizedHost(host).toLowerCase();
+    const version = isIP(value);
+    if (version === 4)
+        return value.startsWith("127.");
+    if (version === 6)
+        return value === "::1" || value.startsWith("::ffff:127.");
+    return false;
+}
+export async function resolvesLoopback(host) {
+    const value = normalizedHost(host);
+    if (value.toLowerCase() === "localhost" || isLoopbackIp(value))
+        return true;
+    try {
+        const records = await lookup(value, { all: true, verbatim: true });
+        return (records.length > 0 &&
+            records.every((record) => isLoopbackIp(record.address)));
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveEndpoint(options = {}) {
+    const env = options.env ?? process.env;
+    const config = loadConfig(options);
+    const configuredHost = configString(config.values, "host");
+    const envHost = env.INTER_AGENT_HOST;
+    const host = envHost || configuredHost || DEFAULT_HOST;
+    const hostSource = envHost ? "env" : configuredHost ? "config" : "default";
+    const configuredPort = config.values.port;
+    const envPortValue = envPort(env);
+    const port = envPortValue ??
+        (configuredPort === undefined || configuredPort === null
+            ? DEFAULT_PORT
+            : parsePort(configuredPort, "inter-agent config key port"));
+    const portSource = envPortValue !== undefined
+        ? "env"
+        : configuredPort === undefined || configuredPort === null
+            ? "default"
+            : "config";
+    const dataDir = dataDirectory(options, config);
+    const configuredTls = configBoolean(config.values, "tls");
+    const envTls = envBoolean(env, "INTER_AGENT_TLS");
+    const loopback = await resolvesLoopback(host);
+    const tls = envTls ?? configuredTls ?? !loopback;
+    const tlsSource = envTls !== undefined
+        ? "env"
+        : configuredTls !== undefined
+            ? "config"
+            : "default";
+    const configuredCert = configString(config.values, "tlsCert");
+    const envCert = env.INTER_AGENT_TLS_CERT;
+    const tlsCertPath = envCert
+        ? expandPath(envCert, options)
+        : configuredCert
+            ? expandPath(configuredCert, options)
+            : join(dataDir, DEFAULT_TLS_CERT_FILENAME);
+    const tlsCertSource = envCert ? "env" : configuredCert ? "config" : "default";
+    const reasons = [];
+    if (!loopback)
+        reasons.push("host is not loopback");
+    return {
+        host: normalizedHost(host),
+        port,
+        dataDir,
+        configPath: config.path,
+        hostSource,
+        portSource,
+        dataDirSource: env.INTER_AGENT_DATA_DIR
+            ? "env"
+            : configString(config.values, "dataDir")
+                ? "config"
+                : "default",
+        tls,
+        tlsSource,
+        scheme: tls ? "wss" : "ws",
+        tlsCertPath,
+        tlsCertSource,
+        supported: reasons.length === 0,
+        ...(reasons.length ? { unsupportedReason: reasons.join("; ") } : {}),
+    };
+}
+export function assertSupportedEndpoint(endpoint) {
+    if (!endpoint.supported)
+        throw new UnsupportedEndpointError(endpoint.unsupportedReason ?? "unsupported transport");
+}
+export function tokenPath(options = {}, config) {
+    return join(dataDirectory(options, config), DEFAULT_TOKEN_FILENAME);
+}
+export function endpointUri(endpoint) {
+    const host = isIP(endpoint.host) === 6 && !endpoint.host.startsWith("[")
+        ? `[${endpoint.host}]`
+        : endpoint.host;
+    return `${endpoint.scheme}://${host}:${endpoint.port}`;
+}
+function ensurePrivateDirectory(path) {
+    try {
+        const existing = lstatSync(path);
+        if (existing.isSymbolicLink() || !existing.isDirectory())
+            throw new ConfigError("inter-agent data directory is not a private directory");
+    }
+    catch (error) {
+        if (error instanceof ConfigError)
+            throw error;
+        mkdirSync(path, { recursive: true, mode: 0o700 });
+    }
+    try {
+        chmodSync(path, 0o700);
+    }
+    catch {
+        // Windows may not support POSIX mode bits.
+    }
+}
+function readToken(path) {
+    if (!existsSync(path))
+        return undefined;
+    let stat;
+    try {
+        stat = lstatSync(path);
+    }
+    catch {
+        throw new ConfigError("unable to inspect inter-agent token file");
+    }
+    if (!stat.isFile())
+        throw new ConfigError("inter-agent token path is not a regular file");
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // Windows may not support POSIX mode bits.
+    }
+    let value;
+    try {
+        value = readFileSync(path, "utf8").trim();
+    }
+    catch {
+        throw new ConfigError("unable to read inter-agent token file");
+    }
+    return value || undefined;
+}
+function createToken(path) {
+    const token = randomBytes(32).toString("base64url");
+    const temp = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    try {
+        const fd = openSync(temp, "wx", 0o600);
+        try {
+            writeFileSync(fd, `${token}\n`, { encoding: "utf8" });
+        }
+        finally {
+            closeSync(fd);
+        }
+        try {
+            chmodSync(temp, 0o600);
+        }
+        catch {
+            // Windows may not support POSIX mode bits.
+        }
+        renameSync(temp, path);
+        try {
+            chmodSync(path, 0o600);
+        }
+        catch {
+            // Windows may not support POSIX mode bits.
+        }
+        return token;
+    }
+    catch (error) {
+        try {
+            unlinkSync(temp);
+        }
+        catch {
+            // Best effort cleanup of this process's private temporary file.
+        }
+        const existing = readToken(path);
+        if (existing)
+            return existing;
+        if (error instanceof ConfigError)
+            throw error;
+        throw new ConfigError("unable to create inter-agent token file");
+    }
+}
+export function resolveSecret(options = {}, config) {
+    const env = options.env ?? process.env;
+    const loaded = config ?? loadConfig(options);
+    const explicitEnv = env.INTER_AGENT_SECRET;
+    if (explicitEnv !== undefined) {
+        if (!explicitEnv.trim())
+            throw new ConfigError("INTER_AGENT_SECRET must not be empty");
+        return { secret: explicitEnv, source: "env", configPath: loaded.path };
+    }
+    const explicitConfig = configString(loaded.values, "secret");
+    if (explicitConfig !== undefined) {
+        if (!explicitConfig.trim())
+            throw new ConfigError("inter-agent config key secret must not be empty");
+        return {
+            secret: explicitConfig,
+            source: "config",
+            configPath: loaded.path,
+        };
+    }
+    const path = tokenPath(options, loaded);
+    ensurePrivateDirectory(dirname(path));
+    const token = readToken(path) ?? createToken(path);
+    return { secret: token, source: "token_file", tokenPath: path };
+}
+//# sourceMappingURL=config.js.map

package/dist/errors.d.ts

@@ -0,0 +1,35 @@
+export type ProtocolErrorCode = "PROTOCOL_ERROR" | "AUTH_FAILED" | "TOO_MANY_CONNECTIONS" | "BAD_ROLE" | "BAD_SESSION" | "SESSION_TAKEN" | "BAD_NAME" | "BAD_LABEL" | "NAME_TAKEN" | "UNKNOWN_OP" | "BAD_TEXT" | "BAD_FROM_NAME" | "BAD_CUSTOM_TYPE" | "TEXT_TOO_LARGE" | "CUSTOM_PAYLOAD_TOO_LARGE" | "UNKNOWN_TARGET" | "AMBIGUOUS_TARGET" | "BAD_CHANNEL" | "CHANNEL_LIMIT_REACHED" | "NOT_SUBSCRIBED" | "UNKNOWN_CHANNEL" | "KICKED";
+export declare class InterAgentError extends Error {
+    readonly kind: string;
+    readonly retryable: boolean;
+    constructor(message: string, kind: string, retryable?: boolean);
+}
+export declare class ConfigError extends InterAgentError {
+    constructor(message: string);
+}
+export declare class UnsupportedEndpointError extends InterAgentError {
+    readonly reason: string;
+    constructor(reason: string);
+}
+export declare class StateError extends InterAgentError {
+    constructor(message: string);
+}
+export declare class ProtocolError extends InterAgentError {
+    readonly code: ProtocolErrorCode;
+    constructor(message: string, code?: ProtocolErrorCode);
+}
+export declare class AuthenticationError extends InterAgentError {
+    constructor(message?: string);
+}
+export declare class ConnectionError extends InterAgentError {
+    constructor(message: string, retryable?: boolean);
+}
+export declare class TimeoutError extends InterAgentError {
+    constructor(message: string);
+}
+export declare class RemoteError extends InterAgentError {
+    readonly code: ProtocolErrorCode;
+    readonly remoteMessage: string;
+    constructor(code: ProtocolErrorCode, message: string, secret?: string);
+}
+export declare function isProtocolErrorCode(value: unknown): value is ProtocolErrorCode;

package/dist/errors.js

@@ -0,0 +1,95 @@
+export class InterAgentError extends Error {
+    kind;
+    retryable;
+    constructor(message, kind, retryable = false) {
+        super(message);
+        this.name = kind;
+        this.kind = kind;
+        this.retryable = retryable;
+    }
+}
+export class ConfigError extends InterAgentError {
+    constructor(message) {
+        super(message, "ConfigError");
+    }
+}
+export class UnsupportedEndpointError extends InterAgentError {
+    reason;
+    constructor(reason) {
+        super(`unsupported inter-agent endpoint: ${reason}`, "UnsupportedEndpointError");
+        this.reason = reason;
+    }
+}
+export class StateError extends InterAgentError {
+    constructor(message) {
+        super(message, "StateError");
+    }
+}
+export class ProtocolError extends InterAgentError {
+    code;
+    constructor(message, code = "PROTOCOL_ERROR") {
+        super(message, "ProtocolError");
+        this.code = code;
+    }
+}
+export class AuthenticationError extends InterAgentError {
+    constructor(message = "inter-agent server authentication failed") {
+        super(message, "AuthenticationError");
+    }
+}
+export class ConnectionError extends InterAgentError {
+    constructor(message, retryable = true) {
+        super(message, "ConnectionError", retryable);
+    }
+}
+export class TimeoutError extends InterAgentError {
+    constructor(message) {
+        super(message, "TimeoutError", true);
+    }
+}
+function redact(value, secret) {
+    if (!secret || !value.includes(secret))
+        return value;
+    return value.split(secret).join("[redacted]");
+}
+export class RemoteError extends InterAgentError {
+    code;
+    remoteMessage;
+    constructor(code, message, secret) {
+        const safeMessage = redact(message, secret);
+        super(`inter-agent ${code}: ${safeMessage}`, "RemoteError", isTransientCode(code));
+        this.code = code;
+        this.remoteMessage = safeMessage;
+    }
+}
+function isTransientCode(code) {
+    return code === "TOO_MANY_CONNECTIONS";
+}
+export function isProtocolErrorCode(value) {
+    return (typeof value === "string" &&
+        [
+            "PROTOCOL_ERROR",
+            "AUTH_FAILED",
+            "TOO_MANY_CONNECTIONS",
+            "BAD_ROLE",
+            "BAD_SESSION",
+            "SESSION_TAKEN",
+            "BAD_NAME",
+            "BAD_LABEL",
+            "NAME_TAKEN",
+            "UNKNOWN_OP",
+            "BAD_TEXT",
+            "BAD_FROM_NAME",
+            "BAD_CUSTOM_TYPE",
+            "TEXT_TOO_LARGE",
+            "CUSTOM_PAYLOAD_TOO_LARGE",
+            "UNKNOWN_TARGET",
+            "AMBIGUOUS_TARGET",
+            "BAD_CHANNEL",
+            "CHANNEL_LIMIT_REACHED",
+            "NOT_SUBSCRIBED",
+            "UNKNOWN_CHANNEL",
+            "KICKED",
+        ].includes(value));
+}
+//# sourceMappingURL=errors.js.map

package/dist/inbox.d.ts

@@ -0,0 +1,31 @@
+export declare const INBOX_VERSION = 1;
+export declare const INBOX_MAX_MESSAGES = 100;
+export declare const INBOX_MAX_BYTES: number;
+export type InboxKind = "direct" | "broadcast";
+export type InboxMessage = {
+    id: string;
+    receivedAt: string;
+    from: string;
+    fromName: string;
+    kind: InboxKind;
+    to: string | null;
+    text: string;
+    notificationTruncated: boolean;
+};
+export type Inbox = {
+    version: 1;
+    messages: InboxMessage[];
+};
+export declare function emptyInbox(): Inbox;
+export declare function encodedInboxSize(inbox: Inbox): number;
+export declare function evictToBounds(messages: InboxMessage[]): InboxMessage[];
+export declare function addMessage(inbox: Inbox, message: InboxMessage): {
+    inbox: Inbox;
+    added: boolean;
+};
+export declare function readInboxFile(dataDir: string, workspaceHash: string, sessionHash: string): Inbox;
+export declare function writeInboxFile(dataDir: string, workspaceHash: string, sessionHash: string, inbox: Inbox): void;
+export declare function recordMessage(dataDir: string, workspaceHash: string, sessionHash: string, message: InboxMessage): {
+    inbox: Inbox;
+    added: boolean;
+};

package/dist/inbox.js

@@ -0,0 +1,94 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { StateError } from "./errors.js";
+import { ensureSessionDir, readJsonFile, sessionDir, writeJsonAtomic, } from "./state.js";
+export const INBOX_VERSION = 1;
+export const INBOX_MAX_MESSAGES = 100;
+export const INBOX_MAX_BYTES = 8 * 1024 * 1024;
+const INBOX_FILENAME = "inbox.json";
+export function emptyInbox() {
+    return { version: INBOX_VERSION, messages: [] };
+}
+export function encodedInboxSize(inbox) {
+    return Buffer.byteLength(JSON.stringify(inbox), "utf8");
+}
+// Eviction drops the oldest records until the count and encoded-size bounds
+// both hold. A single record larger than the total bound is kept as the sole
+// record rather than being discarded.
+export function evictToBounds(messages) {
+    const result = messages.slice();
+    while (result.length > INBOX_MAX_MESSAGES ||
+        encodedInboxSize({ version: INBOX_VERSION, messages: result }) >
+            INBOX_MAX_BYTES) {
+        if (result.length <= 1)
+            break;
+        result.shift();
+    }
+    return result;
+}
+export function addMessage(inbox, message) {
+    if (inbox.messages.some((existing) => existing.id === message.id))
+        return { inbox, added: false };
+    const messages = [...inbox.messages, message];
+    return {
+        inbox: { version: INBOX_VERSION, messages: evictToBounds(messages) },
+        added: true,
+    };
+}
+function isInboxMessage(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const record = value;
+    if (typeof record.id !== "string" || record.id.length === 0)
+        return false;
+    if (typeof record.receivedAt !== "string")
+        return false;
+    if (Number.isNaN(Date.parse(record.receivedAt)))
+        return false;
+    if (typeof record.from !== "string" || record.from.length === 0)
+        return false;
+    if (typeof record.fromName !== "string")
+        return false;
+    if (record.kind !== "direct" && record.kind !== "broadcast")
+        return false;
+    if (record.to !== null && typeof record.to !== "string")
+        return false;
+    if (typeof record.text !== "string")
+        return false;
+    if (typeof record.notificationTruncated !== "boolean")
+        return false;
+    return true;
+}
+function isInbox(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const record = value;
+    if (record.version !== INBOX_VERSION)
+        return false;
+    if (!Array.isArray(record.messages))
+        return false;
+    if (!record.messages.every((message) => isInboxMessage(message)))
+        return false;
+    return true;
+}
+export function readInboxFile(dataDir, workspaceHash, sessionHash) {
+    const dir = sessionDir(dataDir, workspaceHash, sessionHash);
+    const path = join(dir, INBOX_FILENAME);
+    if (!existsSync(path))
+        return emptyInbox();
+    const record = readJsonFile(path);
+    if (!isInbox(record))
+        throw new StateError("session inbox is malformed");
+    return record;
+}
+export function writeInboxFile(dataDir, workspaceHash, sessionHash, inbox) {
+    writeJsonAtomic(join(ensureSessionDir(dataDir, workspaceHash, sessionHash), INBOX_FILENAME), inbox);
+}
+export function recordMessage(dataDir, workspaceHash, sessionHash, message) {
+    const current = readInboxFile(dataDir, workspaceHash, sessionHash);
+    const { inbox, added } = addMessage(current, message);
+    if (added)
+        writeInboxFile(dataDir, workspaceHash, sessionHash, inbox);
+    return { inbox, added };
+}
+//# sourceMappingURL=inbox.js.map