@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/session/external-tool-request.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertExternalToolRequestContext = assertExternalToolRequestContext;
+exports.runExternalToolRequest = runExternalToolRequest;
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const core_1 = require("../rg-wrapper/core");
+const options_1 = require("../rg-wrapper/options");
+const core_2 = require("../rtk-wrapper/core");
+const core_3 = require("../tsc-wrapper/core");
+const request_routing_context_1 = require("../config/request-routing-context");
+function assertExternalToolRequestContext(input) {
+    (0, request_routing_context_1.runWithRequestRoutingContext)(input.cwd, input.env, () => undefined);
+}
+function runExternalToolRequest(input, signal) {
+    return (0, request_routing_context_1.runWithRequestRoutingContext)(input.cwd, input.env, ({ environment }) => runExternalToolRequestInContext({ ...input, environment }, signal));
+}
+async function runExternalToolRequestInContext(input, signal) {
+    if (input.command === "tsc") {
+        const result = await (0, core_3.runAibTscAsync)(input.cwd, input.restArgs, input.environment, signal);
+        return (0, agent_text_1.attachAgentText)({
+            ok: result.ok,
+            command: "tsc",
+            exitCode: result.exitCode,
+            stdout: result.formatted ? `${result.formatted.replace(/\n?$/, "\n")}` : "",
+            stderr: "",
+            logPath: result.logPath,
+            resolution: result.resolution,
+            spawnError: result.spawnError
+        }, result.formatted);
+    }
+    if ((0, core_2.isRtkPassthroughCommand)(input.command)) {
+        return await (0, core_2.runRtkPassthroughAsync)({
+            tool: input.command,
+            args: input.restArgs,
+            cwd: input.cwd,
+            env: input.environment,
+            ...(input.stdinText !== undefined ? { stdinText: input.stdinText } : {})
+        }, signal);
+    }
+    if (input.command !== "rg") {
+        throw new errors_1.CliError("UNSUPPORTED_EXEC_COMMAND", `Unsupported exec command: ${input.command}`, {
+            supported: ["rg --", "tsc --", ...core_2.RTK_PASSTHROUGH_COMMANDS.map((command) => `${command} --`)]
+        });
+    }
+    return await (0, core_1.runBrgFormattedAsync)({
+        args: input.restArgs,
+        cwd: input.cwd,
+        env: input.environment,
+        ...(input.stdinText !== undefined ? { stdinText: input.stdinText } : {})
+    }, (0, options_1.resolveBrgFormatOptions)(input.cwd, input.restArgs, input.environment), signal);
+}

package/dist/session/lane-owner.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acquireSessionLaneLease = acquireSessionLaneLease;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const errors_1 = require("../shared/errors");
+const paths_1 = require("./paths");
+/** Claim the one active daemon slot for this runtime lane. */
+function acquireSessionLaneLease(cliPath) {
+    fs.mkdirSync((0, paths_1.getSessionDir)(), { recursive: true });
+    const ownerPath = (0, paths_1.getSessionOwnerPath)();
+    const record = {
+        schemaVersion: 1,
+        pid: process.pid,
+        token: crypto.randomBytes(12).toString("hex"),
+        generationId: crypto.createHash("sha256").update(path.resolve(cliPath)).digest("hex").slice(0, 16),
+        cliPath: path.resolve(cliPath),
+        startedAt: new Date().toISOString()
+    };
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            const fd = fs.openSync(ownerPath, "wx");
+            try {
+                fs.writeFileSync(fd, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            return {
+                record,
+                release: () => releaseIfOwned(ownerPath, record.token)
+            };
+        }
+        catch (error) {
+            if (!isAlreadyExists(error))
+                throw error;
+            const existing = readOwner(ownerPath);
+            if (existing && isProcessAlive(existing.pid)) {
+                throw new errors_1.CliError("SESSION_LANE_ALREADY_OWNED", "An AIB daemon already owns this runtime lane.", {
+                    ownerPid: existing.pid,
+                    generationId: existing.generationId,
+                    sessionDir: (0, paths_1.getSessionDir)()
+                });
+            }
+            fs.rmSync(ownerPath, { force: true });
+        }
+    }
+    throw new errors_1.CliError("SESSION_LANE_CLAIM_FAILED", "AIB could not claim the runtime lane.", {
+        sessionDir: (0, paths_1.getSessionDir)()
+    });
+}
+function releaseIfOwned(ownerPath, token) {
+    const existing = readOwner(ownerPath);
+    if (existing?.token === token)
+        fs.rmSync(ownerPath, { force: true });
+}
+function readOwner(filePath) {
+    try {
+        const value = JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return value.schemaVersion === 1 && typeof value.pid === "number" && typeof value.token === "string"
+            && typeof value.generationId === "string" && typeof value.cliPath === "string" && typeof value.startedAt === "string"
+            ? value
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isAlreadyExists(error) {
+    return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST");
+}
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/session/paths.js

@@ -1 +1,71 @@
-"use strict";var u=exports&&exports.__createBinding||(Object.create?(function(r,e,n,t){t===void 0&&(t=n);var i=Object.getOwnPropertyDescriptor(e,n);(!i||("get"in i?!e.__esModule:i.writable||i.configurable))&&(i={enumerable:!0,get:function(){return e[n]}}),Object.defineProperty(r,t,i)}):(function(r,e,n,t){t===void 0&&(t=n),r[t]=e[n]})),c=exports&&exports.__setModuleDefault||(Object.create?(function(r,e){Object.defineProperty(r,"default",{enumerable:!0,value:e})}):function(r,e){r.default=e}),s=exports&&exports.__importStar||(function(){var r=function(e){return r=Object.getOwnPropertyNames||function(n){var t=[];for(var i in n)Object.prototype.hasOwnProperty.call(n,i)&&(t[t.length]=i);return t},r(e)};return function(e){if(e&&e.__esModule)return e;var n={};if(e!=null)for(var t=r(e),i=0;i<t.length;i++)t[i]!=="default"&&u(n,e,t[i]);return c(n,e),n}})();Object.defineProperty(exports,"__esModule",{value:!0}),exports.getSessionDir=o,exports.getSessionInfoPath=b,exports.getSessionUrlPath=g;const a=s(require("node:os")),f=s(require("node:path")),l=require("../config/env-vars");function o(){const r=process.env[l.CLI_ENV.cliSessionDir]?.trim();if(r)return f.resolve(r);const e=f.resolve(__dirname,"..","bin","aib.js"),n=process.platform==="win32"?e.toLowerCase():e,t=_(n);return f.join(a.tmpdir(),"aib",`cli-session-${t}`)}function _(r){let e=0xcbf29ce484222325n;const n=0x100000001b3n,t=0xffffffffffffffffn;for(const i of Buffer.from(r,"utf8"))e^=BigInt(i),e=e*n&t;return e.toString(16).slice(0,12)}function b(){return f.join(o(),"cli-session.json")}function g(){return f.join(o(),"cli-session.url")}
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionDir = getSessionDir;
+exports.getSessionInfoPath = getSessionInfoPath;
+exports.getSessionUrlPath = getSessionUrlPath;
+exports.getSessionOwnerPath = getSessionOwnerPath;
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const env_vars_1 = require("../config/env-vars");
+function getSessionDir() {
+    const explicit = process.env[env_vars_1.CLI_ENV.cliSessionDir]?.trim();
+    if (explicit) {
+        return path.resolve(explicit);
+    }
+    const cliEntrypoint = path.resolve(__dirname, "..", "bin", "aib.js");
+    const normalized = process.platform === "win32" ? cliEntrypoint.toLowerCase() : cliEntrypoint;
+    const channel = fnv1aHex12(normalized);
+    return path.join(os.tmpdir(), "aib", `cli-session-${channel}`);
+}
+function fnv1aHex12(value) {
+    let hash = 0xcbf29ce484222325n;
+    const prime = 0x100000001b3n;
+    const mask = 0xffffffffffffffffn;
+    for (const byte of Buffer.from(value, "utf8")) {
+        hash ^= BigInt(byte);
+        hash = (hash * prime) & mask;
+    }
+    return hash.toString(16).slice(0, 12);
+}
+function getSessionInfoPath() {
+    return path.join(getSessionDir(), "cli-session.json");
+}
+function getSessionUrlPath() {
+    return path.join(getSessionDir(), "cli-session.url");
+}
+function getSessionOwnerPath() {
+    return path.join(getSessionDir(), "cli-session.owner.json");
+}

package/dist/session/runtime-lifecycle.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionRuntimeLifecycle = void 0;
+exports.runWithSessionRuntimeLifecycle = runWithSessionRuntimeLifecycle;
+exports.trackSessionBackgroundPromise = trackSessionBackgroundPromise;
+exports.trackSessionOwnedProcess = trackSessionOwnedProcess;
+exports.readSessionIdleTtlMs = readSessionIdleTtlMs;
+exports.readSessionDrainTimeoutMs = readSessionDrainTimeoutMs;
+const node_async_hooks_1 = require("node:async_hooks");
+const env_vars_1 = require("../config/env-vars");
+const errors_1 = require("../shared/errors");
+const runtimeLifecycleStorage = new node_async_hooks_1.AsyncLocalStorage();
+const MAX_RETAINERS = 12;
+const DEFAULT_SESSION_IDLE_TTL_MS = 15 * 60_000;
+const DEFAULT_SESSION_DRAIN_TIMEOUT_MS = 5_000;
+/** In-memory idle lease for one CLI session lane. */
+class SessionRuntimeLifecycle {
+    idleTtlMs;
+    onIdle;
+    externalRetainers;
+    now;
+    backgroundReasons = new Map();
+    processReasons = new Map();
+    lastActivityMs;
+    activeRequests = 0;
+    backgroundJobs = 0;
+    ownedProcesses = 0;
+    phase = "running";
+    shutdownReason = null;
+    timer = null;
+    started = false;
+    constructor(options) {
+        this.idleTtlMs = Math.max(0, Math.floor(options.idleTtlMs));
+        this.onIdle = options.onIdle;
+        this.externalRetainers = options.externalRetainers;
+        this.now = options.now ?? Date.now;
+        this.lastActivityMs = this.now();
+    }
+    get state() {
+        const deadline = this.idleDeadlineMs();
+        return {
+            phase: this.phase,
+            acceptingRequests: this.phase === "running",
+            idleTtlMs: this.idleTtlMs,
+            lastActivityAt: new Date(this.lastActivityMs).toISOString(),
+            idleDeadlineAt: deadline === null ? null : new Date(deadline).toISOString(),
+            activeRequests: this.activeRequests,
+            backgroundJobs: this.backgroundJobs,
+            ownedProcesses: this.ownedProcesses,
+            retainers: this.collectRetainers(),
+            shutdownReason: this.shutdownReason
+        };
+    }
+    start() {
+        if (this.started || this.phase !== "running")
+            return;
+        this.started = true;
+        this.scheduleIdleCheck();
+    }
+    beginRequest() {
+        if (this.phase !== "running") {
+            throw new errors_1.CliError("SESSION_RUNTIME_DRAINING", "The AIB session runtime is draining and no longer accepts new requests.", {
+                phase: this.phase,
+                shutdownReason: this.shutdownReason
+            });
+        }
+        this.activeRequests += 1;
+        this.renewActivity();
+        let finished = false;
+        return () => {
+            if (finished)
+                return;
+            finished = true;
+            this.activeRequests = Math.max(0, this.activeRequests - 1);
+            this.renewActivity();
+        };
+    }
+    trackBackgroundPromise(promise, reason = "background-job") {
+        if (this.phase === "stopped")
+            return promise;
+        this.backgroundJobs += 1;
+        increment(this.backgroundReasons, reason);
+        this.renewActivity();
+        return promise.finally(() => {
+            this.backgroundJobs = Math.max(0, this.backgroundJobs - 1);
+            decrement(this.backgroundReasons, reason);
+            this.renewActivity();
+        });
+    }
+    trackOwnedProcess(process, reason = "owned-child-process") {
+        if (this.phase === "stopped")
+            return;
+        this.ownedProcesses += 1;
+        increment(this.processReasons, reason);
+        this.renewActivity();
+        let finished = false;
+        const finish = () => {
+            if (finished)
+                return;
+            finished = true;
+            process.removeListener("exit", finish);
+            process.removeListener("error", finish);
+            this.ownedProcesses = Math.max(0, this.ownedProcesses - 1);
+            decrement(this.processReasons, reason);
+            this.renewActivity();
+        };
+        process.once("exit", finish);
+        process.once("error", finish);
+    }
+    beginShutdown(reason) {
+        if (this.phase !== "running")
+            return false;
+        this.phase = "draining";
+        this.shutdownReason = reason;
+        this.clearTimer();
+        return true;
+    }
+    markStopped() {
+        this.phase = "stopped";
+        this.clearTimer();
+    }
+    async waitForDrain(timeoutMs) {
+        const deadline = this.now() + Math.max(0, timeoutMs);
+        while (this.collectRetainers().length > 0) {
+            if (this.now() >= deadline)
+                return false;
+            await delay(Math.min(10, Math.max(1, deadline - this.now())));
+        }
+        return true;
+    }
+    renewActivity() {
+        this.lastActivityMs = this.now();
+        if (this.started && this.phase === "running")
+            this.scheduleIdleCheck();
+    }
+    scheduleIdleCheck(delayOverride) {
+        this.clearTimer();
+        const deadline = this.idleDeadlineMs();
+        if (deadline === null || this.phase !== "running")
+            return;
+        const delayMs = delayOverride ?? Math.max(1, deadline - this.now());
+        this.timer = setTimeout(() => this.checkIdle(), delayMs);
+        this.timer.unref();
+    }
+    checkIdle() {
+        this.timer = null;
+        if (this.phase !== "running")
+            return;
+        const deadline = this.idleDeadlineMs();
+        if (deadline === null)
+            return;
+        const remaining = deadline - this.now();
+        if (remaining > 0) {
+            this.scheduleIdleCheck(remaining);
+            return;
+        }
+        if (this.collectRetainers().length > 0) {
+            this.scheduleIdleCheck(Math.min(1_000, Math.max(10, this.idleTtlMs)));
+            return;
+        }
+        if (!this.beginShutdown("idle-ttl"))
+            return;
+        void Promise.resolve(this.onIdle()).catch(() => undefined);
+    }
+    idleDeadlineMs() {
+        return this.idleTtlMs > 0 && this.phase === "running"
+            ? this.lastActivityMs + this.idleTtlMs
+            : null;
+    }
+    collectRetainers() {
+        const retainers = [];
+        if (this.activeRequests > 0)
+            retainers.push(`requests:${this.activeRequests}`);
+        for (const [reason, count] of this.backgroundReasons)
+            retainers.push(`${reason}:${count}`);
+        for (const [reason, count] of this.processReasons)
+            retainers.push(`${reason}:${count}`);
+        for (const reason of this.externalRetainers?.() ?? []) {
+            if (reason.trim())
+                retainers.push(reason.trim());
+        }
+        return retainers.slice(0, MAX_RETAINERS);
+    }
+    clearTimer() {
+        if (!this.timer)
+            return;
+        clearTimeout(this.timer);
+        this.timer = null;
+    }
+}
+exports.SessionRuntimeLifecycle = SessionRuntimeLifecycle;
+function runWithSessionRuntimeLifecycle(lifecycle, callback) {
+    return runtimeLifecycleStorage.run(lifecycle, callback);
+}
+function trackSessionBackgroundPromise(promise, reason) {
+    return runtimeLifecycleStorage.getStore()?.trackBackgroundPromise(promise, reason) ?? promise;
+}
+function trackSessionOwnedProcess(process, reason) {
+    runtimeLifecycleStorage.getStore()?.trackOwnedProcess(process, reason);
+}
+function readSessionIdleTtlMs(env = process.env) {
+    return readNonNegativeEnvMs(env[env_vars_1.CLI_ENV.cliSessionIdleTtlMs], DEFAULT_SESSION_IDLE_TTL_MS);
+}
+function readSessionDrainTimeoutMs(env = process.env) {
+    return readNonNegativeEnvMs(env[env_vars_1.CLI_ENV.cliSessionDrainTimeoutMs], DEFAULT_SESSION_DRAIN_TIMEOUT_MS);
+}
+function increment(values, key) {
+    values.set(key, (values.get(key) ?? 0) + 1);
+}
+function decrement(values, key) {
+    const next = (values.get(key) ?? 1) - 1;
+    if (next <= 0)
+        values.delete(key);
+    else
+        values.set(key, next);
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function readNonNegativeEnvMs(raw, fallback) {
+    if (raw === undefined || raw.trim() === "")
+        return fallback;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}

package/dist/session/runtime-shutdown.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finalizeSessionRuntimeBestEffort = finalizeSessionRuntimeBestEffort;
+exports.shutdownSessionRuntime = shutdownSessionRuntime;
+function finalizeSessionRuntimeBestEffort(cleanups, terminal) {
+    for (const cleanup of cleanups) {
+        try {
+            cleanup();
+        }
+        catch {
+            // Every cleanup is independent. Later release/terminal steps must run.
+        }
+    }
+    try {
+        terminal();
+    }
+    catch {
+        // The shutdown caller still has its hard-exit boundary.
+    }
+}
+/** Stop admission, drain bounded ownership, then release one session lane. */
+async function shutdownSessionRuntime(options) {
+    const hardTimer = setTimeout(options.hardExit, Math.max(1, options.drainTimeoutMs + (options.hardExitGraceMs ?? 5_000)));
+    try {
+        const drained = await options.lifecycle.waitForDrain(options.drainTimeoutMs);
+        let serverClosed = false;
+        let forcedConnectionsClosed = false;
+        let resolveClose;
+        const closePromise = new Promise((resolve) => { resolveClose = resolve; });
+        const forceCloseConnections = () => {
+            if (forcedConnectionsClosed)
+                return;
+            forcedConnectionsClosed = true;
+            try {
+                options.server.closeAllConnections?.();
+            }
+            catch {
+                // The hard-exit boundary remains armed until terminal finalization.
+            }
+        };
+        try {
+            options.server.close(() => {
+                serverClosed = true;
+                resolveClose();
+            });
+        }
+        catch {
+            forceCloseConnections();
+            resolveClose();
+        }
+        if (drained)
+            options.server.closeIdleConnections?.();
+        else
+            forceCloseConnections();
+        try {
+            await options.shutdownResources();
+        }
+        catch {
+            // Shutdown is best-effort once admission has stopped. A single resource
+            // must not prevent the lane identity/lease from being released.
+        }
+        await Promise.race([closePromise, delay(250)]);
+        if (!serverClosed)
+            forceCloseConnections();
+        const result = {
+            drained,
+            forcedConnectionsClosed
+        };
+        try {
+            options.finalize(result);
+        }
+        catch {
+            invokeHardExit(options.hardExit);
+        }
+        return result;
+    }
+    catch {
+        invokeHardExit(options.hardExit);
+        return { drained: false, forcedConnectionsClosed: true };
+    }
+    finally {
+        clearTimeout(hardTimer);
+    }
+}
+function invokeHardExit(hardExit) {
+    try {
+        hardExit();
+    }
+    catch {
+        // Production hardExit terminates the process; tests may use a throwing seam.
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}