aligndev 0.0.0 → 0.19.0

package/dist/code/quota.js

@@ -0,0 +1,248 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { buildAgentEnv } from "./run-agent.js";
+const QUOTA_TIMEOUT_MS = 30_000;
+const CLAUDE_PRIVACY_OPT_OUTS = [
+    "DISABLE_TELEMETRY",
+    "DISABLE_ERROR_REPORTING",
+    "DISABLE_FEEDBACK_COMMAND",
+    "DISABLE_BUG_COMMAND",
+    "CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY",
+];
+const execFileAsync = promisify(execFile);
+const DEFAULT_QUOTA_PROCESS_ADAPTER = {
+    execute: executeQuotaProcess,
+    spawn: spawnQuotaProcess,
+};
+export const readQuota = createQuotaReader();
+export function createQuotaReader(adapter = DEFAULT_QUOTA_PROCESS_ADAPTER, timeoutMs = QUOTA_TIMEOUT_MS) {
+    return async (agent, context) => {
+        const env = buildAgentEnv(context.env, context.unset);
+        return agent === "claude"
+            ? readClaudeQuota({ ...context, env: translateClaudePrivacyOptOut(env) }, adapter, timeoutMs)
+            : readCodexQuota({ ...context, env }, adapter, timeoutMs);
+    };
+}
+function translateClaudePrivacyOptOut(env) {
+    if (env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC === undefined)
+        return env;
+    delete env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC;
+    for (const name of CLAUDE_PRIVACY_OPT_OUTS)
+        env[name] = "1";
+    return env;
+}
+async function readClaudeQuota(context, adapter, timeoutMs) {
+    const { stdout } = await adapter.execute("claude", ["-p", "/usage", "--tools", "", "--output-format", "json", "--no-session-persistence"], {
+        cwd: context.cwd,
+        env: context.env,
+        timeout: timeoutMs,
+    });
+    return `Claude Code quota\n\n${parseClaudeQuota(stdout)}`;
+}
+export function parseClaudeQuota(stdout) {
+    let value;
+    try {
+        value = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error("Claude Code returned malformed usage JSON.");
+    }
+    if (!isRecord(value))
+        throw new Error("Claude Code returned an unexpected usage response.");
+    const result = value.result;
+    if (value.is_error === true || value.subtype !== "success" || typeof result !== "string") {
+        throw new Error("Claude Code could not read the current usage limits.");
+    }
+    const insightsStart = result.search(/^What's contributing to your limits usage\?/m);
+    const limits = (insightsStart === -1 ? result : result.slice(0, insightsStart)).trimEnd();
+    if (!/\d+% used/.test(limits))
+        throw new Error("Claude Code returned no usage limits.");
+    return limits;
+}
+async function readCodexQuota(context, adapter, timeoutMs) {
+    const response = await requestCodexQuota(context, adapter, timeoutMs);
+    return formatCodexQuota(response);
+}
+function requestCodexQuota(context, adapter, timeoutMs) {
+    const child = adapter.spawn("codex", ["app-server"], {
+        cwd: context.cwd,
+        env: context.env,
+    });
+    return exchangeCodexMessages(child, timeoutMs);
+}
+function exchangeCodexMessages(child, timeoutMs) {
+    const detachGuard = guardChild(child);
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (error, result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            detachGuard();
+            child.kill("SIGTERM");
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        };
+        const timer = setTimeout(() => finish(new Error("Codex timed out while reading usage limits.")), timeoutMs);
+        const readStderr = observeCodexOutput(child, finish);
+        observeCodexLifecycle(child, finish, () => settled, readStderr);
+        initializeCodex(child);
+    });
+}
+function guardChild(child) {
+    const kill = () => {
+        if (child.exitCode === null && child.signalCode === null)
+            child.kill("SIGTERM");
+    };
+    process.on("exit", kill);
+    return () => process.off("exit", kill);
+}
+function observeCodexOutput(child, finish) {
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+        stdout = drainJsonLines(stdout, (message) => handleCodexMessage(child, message, finish));
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+        stderr += chunk;
+    });
+    return () => stderr;
+}
+function drainJsonLines(buffer, onMessage) {
+    const lines = buffer.split("\n");
+    const rest = lines.pop() ?? "";
+    for (const line of lines) {
+        if (line.trim() === "")
+            continue;
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (isRecord(value))
+            onMessage(value);
+    }
+    return rest;
+}
+function handleCodexMessage(child, message, finish) {
+    if (message.id === 0 && message.result !== undefined) {
+        sendCodexMessage(child, { method: "initialized", params: {} });
+        sendCodexMessage(child, { method: "account/rateLimits/read", id: 1 });
+    }
+    if (message.id !== 1)
+        return;
+    if (isRecord(message.error)) {
+        const detail = message.error.message;
+        finish(new Error(typeof detail === "string"
+            ? `Codex could not read usage limits: ${detail}`
+            : "Codex could not read the current usage limits."));
+        return;
+    }
+    finish(undefined, message.result);
+}
+function sendCodexMessage(child, message) {
+    child.stdin.write(`${JSON.stringify(message)}\n`);
+}
+function observeCodexLifecycle(child, finish, isSettled, readStderr) {
+    child.stdin.on("error", (error) => {
+        finish(new Error(`Codex could not read usage limits: ${error.message}`));
+    });
+    child.on("error", (error) => finish(error));
+    child.on("close", (code) => {
+        if (isSettled())
+            return;
+        const detail = readStderr().trim();
+        finish(new Error(detail !== ""
+            ? `Codex could not read usage limits: ${detail}`
+            : `Codex app-server exited with code ${code ?? "unknown"}.`));
+    });
+}
+function initializeCodex(child) {
+    sendCodexMessage(child, {
+        method: "initialize",
+        id: 0,
+        params: {
+            clientInfo: {
+                name: "aligndev",
+                title: "AlignFirst aligndev",
+                version: "0.0.0",
+            },
+        },
+    });
+}
+async function executeQuotaProcess(file, args, options) {
+    const { stdout } = await execFileAsync(file, args, {
+        ...options,
+        encoding: "utf8",
+    });
+    return { stdout };
+}
+function spawnQuotaProcess(file, args, options) {
+    return spawn(file, args, { ...options, stdio: ["pipe", "pipe", "pipe"] });
+}
+export function formatCodexQuota(response, formatTime = formatLocalTime) {
+    const bucket = parseCodexBucket(response);
+    return `Codex quota\n\n${formatBucket(bucket, formatTime)}`;
+}
+function parseCodexBucket(response) {
+    if (!isRecord(response))
+        throw new Error("Codex returned an unexpected usage response.");
+    const bucket = parseBucket(response.rateLimits);
+    if (bucket === undefined) {
+        throw new Error("Codex returned no usage windows for the current account.");
+    }
+    return bucket;
+}
+function parseBucket(value) {
+    if (!isRecord(value))
+        return;
+    const windows = [parseWindow(value.primary), parseWindow(value.secondary)].filter((window) => window !== undefined);
+    if (windows.length === 0)
+        return;
+    return { windows };
+}
+function parseWindow(value) {
+    if (!isRecord(value) || typeof value.usedPercent !== "number")
+        return;
+    return {
+        usedPercent: value.usedPercent,
+        windowDurationMins: typeof value.windowDurationMins === "number" ? value.windowDurationMins : null,
+        resetsAt: typeof value.resetsAt === "number" ? value.resetsAt : null,
+    };
+}
+function formatBucket(bucket, formatTime) {
+    const windows = bucket.windows.map((window, index) => {
+        const duration = formatDuration(window.windowDurationMins, index);
+        const reset = window.resetsAt === null ? "" : ` · resets ${formatTime(window.resetsAt)}`;
+        return `  ${duration}: ${window.usedPercent}% used${reset}`;
+    });
+    return `Codex\n${windows.join("\n")}`;
+}
+function formatDuration(minutes, index) {
+    if (minutes === null)
+        return index === 0 ? "Primary window" : "Secondary window";
+    if (minutes % 10_080 === 0)
+        return plural(minutes / 10_080, "week");
+    if (minutes % 1_440 === 0)
+        return plural(minutes / 1_440, "day");
+    if (minutes % 60 === 0)
+        return plural(minutes / 60, "hour");
+    return plural(minutes, "minute");
+}
+function plural(value, unit) {
+    return `${value} ${unit}${value === 1 ? "" : "s"}`;
+}
+function formatLocalTime(timestampSeconds) {
+    return new Intl.DateTimeFormat(undefined, { dateStyle: "medium", timeStyle: "short" }).format(new Date(timestampSeconds * 1000));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/code/run-agent.d.ts

@@ -0,0 +1,60 @@
+import { type ChildProcess } from "node:child_process";
+import type { Output } from "../output.js";
+import { type CompletionUpdate } from "./session-file.js";
+export interface RunConfig {
+    prompt: string;
+    sessionFilePath: string;
+    cwd: string;
+    resume?: string;
+    executableModel: string | undefined;
+    skipPermissions: boolean;
+    additionalDirectories: readonly string[];
+    unset: readonly string[];
+    env: NodeJS.ProcessEnv;
+}
+export interface RunResult {
+    status: "succeeded" | "failed";
+    authRequired: boolean;
+    sessionId: string | null;
+    result: string;
+}
+export interface AgentProtocolState {
+    sessionId?: string;
+    result?: string;
+    failure?: string;
+    protocolComplete: boolean;
+    protocolFailed: boolean;
+    authEvidence: boolean;
+    contextTokens?: number;
+    peakContextTokens?: number;
+    streamTotalTokens?: number;
+}
+export interface AgentAssessment {
+    succeeded: boolean;
+    sessionId?: string;
+    result?: string;
+    error?: string;
+    authEvidence: boolean;
+    contextTokens?: number;
+    contextCompacted?: boolean;
+    contextTokensError?: string;
+}
+export interface AgentAdapter {
+    executable: string;
+    buildArgs(config: RunConfig): string[];
+    createState(): AgentProtocolState;
+    interpretLine(line: string, state: AgentProtocolState): string | undefined;
+    assess(state: AgentProtocolState): AgentAssessment;
+    isAuthenticationError(message: string): boolean;
+    authenticationMessage(detail?: string): string;
+    failureMessage?(state: AgentProtocolState): string;
+}
+export type SpawnAgentProcess = (command: string, args: readonly string[], options: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    stdio: ["pipe", "pipe", "pipe"];
+}) => ChildProcess;
+export declare function runAgent(config: RunConfig, adapter: AgentAdapter, out: Output, spawnProcess?: SpawnAgentProcess): Promise<RunResult>;
+export declare function buildAgentEnv(baseEnv: NodeJS.ProcessEnv, unset: readonly string[]): NodeJS.ProcessEnv;
+export declare function buildTerminationUpdate(signal: NodeJS.Signals, state: AgentProtocolState, now: Date): CompletionUpdate;
+export declare function isCompacted(state: AgentProtocolState): boolean;

package/dist/code/run-agent.js

@@ -0,0 +1,212 @@
+import { spawn } from "node:child_process";
+import { appendTranscript, applyCompletion } from "./session-file.js";
+const TERMINATION_GRACE_MS = 2000;
+// A coding-agent session exports its own identity to every command it runs; when the assistant
+// runs in one, the coder must not inherit it.
+const ASSISTANT_SESSION_VARIABLES = [
+    "CLAUDECODE",
+    "CLAUDE_CODE_SESSION_ID",
+    "CLAUDE_CODE_CHILD_SESSION",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_MESSAGING_SOCKET",
+    "CLAUDE_CODE_MESSAGING_TOKEN",
+    "CLAUDE_CODE_SESSION_ATTENDED",
+    "CLAUDE_CODE_EXECPATH",
+    "CLAUDE_PID",
+    "CLAUDE_EFFORT",
+    "CODEX_SESSION_ID",
+    "CODEX_THREAD_ID",
+    "CODEX_CI",
+    "CODEX_SANDBOX_NETWORK_DISABLED",
+];
+export async function runAgent(config, adapter, out, spawnProcess = spawnDirectChild) {
+    const state = adapter.createState();
+    const outcome = await spawnAgent(config, adapter, state, out, spawnProcess);
+    const assessment = adapter.assess(state);
+    const failed = outcome.exitCode !== 0 || !assessment.succeeded;
+    // Authentication evidence matters only when the run failed. Claude can recover after retrying
+    // a 401, so evidence from a successful run must not produce an auth_required result.
+    const authRequired = failed && (assessment.authEvidence || adapter.isAuthenticationError(outcome.stderr));
+    const result = selectResult(adapter, state, assessment, outcome, authRequired);
+    applyCompletion(config.sessionFilePath, {
+        status: failed ? "failed" : "succeeded",
+        endedAt: new Date().toISOString(),
+        exitReason: authRequired ? "auth_required" : failed ? "error" : "completed",
+        sessionId: assessment.sessionId ?? null,
+        result,
+        contextTokens: assessment.contextTokens ?? null,
+        contextCompacted: assessment.contextCompacted ?? false,
+        contextTokensError: assessment.contextTokensError ?? null,
+    });
+    return {
+        status: failed ? "failed" : "succeeded",
+        authRequired,
+        sessionId: assessment.sessionId ?? null,
+        result,
+    };
+}
+function spawnDirectChild(command, args, options) {
+    return spawn(command, args, options);
+}
+function selectResult(adapter, state, assessment, outcome, authRequired) {
+    if (authRequired) {
+        return adapter.authenticationMessage(assessment.error ?? nonblank(outcome.stderr));
+    }
+    if (assessment.succeeded && outcome.exitCode === 0 && assessment.result !== undefined) {
+        return assessment.result;
+    }
+    return (assessment.error ??
+        nonblank(outcome.stderr) ??
+        (!assessment.succeeded ? adapter.failureMessage?.(state) : undefined) ??
+        `${adapter.executable} exited with code ${outcome.exitCode ?? "unknown"}`);
+}
+function spawnAgent(config, adapter, state, out, spawnProcess) {
+    const child = spawnProcess(adapter.executable, adapter.buildArgs(config), {
+        cwd: config.cwd,
+        env: buildAgentEnv(config.env, config.unset),
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    const detachChildGuards = guardChildLifecycle(child, config.sessionFilePath, state);
+    let buffer = "";
+    let stderr = "";
+    let inputError;
+    child.stdout?.setEncoding("utf-8");
+    child.stdout?.on("data", (chunk) => {
+        buffer += chunk;
+        buffer = drainLines(buffer, (line) => emitLine(config, adapter, line, state, out));
+    });
+    child.stderr?.setEncoding("utf-8");
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk;
+    });
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            detachChildGuards();
+            resolve(outcome);
+        };
+        child.on("close", (code) => {
+            if (buffer.trim() !== "")
+                emitLine(config, adapter, buffer, state, out);
+            finish({
+                exitCode: inputError === undefined ? code : 1,
+                stderr: inputError === undefined
+                    ? stderr
+                    : `${stderr}\nCould not send prompt: ${inputError.message}`,
+            });
+        });
+        child.on("error", (err) => finish({ exitCode: 1, stderr: err.message }));
+        child.stdin?.on("error", (error) => {
+            inputError = error;
+            child.kill("SIGTERM");
+        });
+        child.stdin?.end(config.prompt, "utf8");
+    });
+}
+function emitLine(config, adapter, line, state, out) {
+    const rendered = adapter.interpretLine(line, state);
+    if (rendered === undefined)
+        return;
+    appendTranscript(config.sessionFilePath, `${rendered}\n`);
+    out.write(`${rendered}\n`);
+}
+function drainLines(buffer, onLine) {
+    const lines = buffer.split("\n");
+    const rest = lines.pop() ?? "";
+    for (const line of lines) {
+        if (line.trim() !== "")
+            onLine(line);
+    }
+    return rest;
+}
+export function buildAgentEnv(baseEnv, unset) {
+    const env = { ...baseEnv };
+    for (const name of ASSISTANT_SESSION_VARIABLES)
+        delete env[name];
+    for (const name of unset) {
+        const trimmed = name.trim();
+        if (trimmed !== "")
+            delete env[trimmed];
+    }
+    return env;
+}
+function guardChildLifecycle(child, sessionFilePath, state) {
+    // Seal the session, ask the child to stop, then force-kill it after a short grace period so
+    // interrupted runs leave neither a stale session record nor an orphaned child process.
+    const isAlive = () => child.exitCode === null && child.signalCode === null;
+    const signalChild = (signal) => {
+        if (!isAlive())
+            return;
+        try {
+            child.kill(signal);
+        }
+        catch {
+            // The child exited between the liveness check and the signal.
+        }
+    };
+    const forceKill = () => signalChild("SIGKILL");
+    const onSignal = async (signal) => {
+        try {
+            applyCompletion(sessionFilePath, buildTerminationUpdate(signal, state, new Date()));
+        }
+        catch {
+            // Session sealing is best-effort when the file is missing or malformed.
+        }
+        signalChild("SIGTERM");
+        await waitForChildExit(child, TERMINATION_GRACE_MS);
+        forceKill();
+        process.exit(signal === "SIGINT" ? 130 : 143);
+    };
+    const onSigint = () => onSignal("SIGINT");
+    const onSigterm = () => onSignal("SIGTERM");
+    process.on("SIGINT", onSigint);
+    process.on("SIGTERM", onSigterm);
+    process.on("exit", forceKill);
+    return () => {
+        process.off("SIGINT", onSigint);
+        process.off("SIGTERM", onSigterm);
+        process.off("exit", forceKill);
+    };
+}
+function waitForChildExit(child, graceMs) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const onExit = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            child.off("exit", onExit);
+            resolve();
+        }, graceMs);
+        child.once("exit", onExit);
+    });
+}
+export function buildTerminationUpdate(signal, state, now) {
+    return {
+        status: "failed",
+        endedAt: now.toISOString(),
+        exitReason: "terminated",
+        sessionId: state.sessionId ?? null,
+        result: `Terminated by ${signal} before completion.`,
+        contextTokens: state.contextTokens ?? null,
+        contextCompacted: isCompacted(state),
+        contextTokensError: null,
+    };
+}
+// Occupancy only falls when the agent compacts the conversation, so a peak above the final figure
+// is the compaction itself.
+export function isCompacted(state) {
+    const { contextTokens, peakContextTokens } = state;
+    if (contextTokens === undefined || peakContextTokens === undefined)
+        return false;
+    return peakContextTokens > contextTokens;
+}
+function nonblank(value) {
+    const trimmed = value.trim();
+    return trimmed === "" ? undefined : trimmed;
+}

package/dist/code/session-file.d.ts

@@ -0,0 +1,50 @@
+import type { CodingAgent } from "./coding-agent.js";
+export interface SessionFrontmatter {
+    status: "running" | "succeeded" | "failed";
+    agent: CodingAgent | null;
+    protocol: string | null;
+    ticket: string | null;
+    model: string | null;
+    sessionId: string | null;
+    command: string;
+    meta: string | null;
+    pid: number | null;
+    pidStartTime: string | null;
+    cwd: string | null;
+    startedAt: string;
+    endedAt: string | null;
+    exitReason: string | null;
+    contextTokens: number | null;
+    contextCompacted: boolean;
+    contextTokensError: string | null;
+}
+export declare const RESULT_MARKER = "\n---- Result ----\n";
+export declare function resolveSessionFilePath(sessionsDir: string, ticket: string | undefined, now: Date, fileExists?: (path: string) => boolean): string;
+export declare function writeInitialSessionFile(sessionFilePath: string, frontmatter: SessionFrontmatter): void;
+export interface CompletionUpdate {
+    status: "succeeded" | "failed";
+    endedAt: string;
+    exitReason: "completed" | "error" | "terminated" | "auth_required";
+    sessionId: string | null;
+    result: string;
+    contextTokens?: number | null;
+    contextCompacted?: boolean;
+    contextTokensError?: string | null;
+}
+export declare function applyCompletion(sessionFilePath: string, update: CompletionUpdate): void;
+export declare function appendTranscript(sessionFilePath: string, text: string): void;
+export interface SessionCompletion {
+    frontmatter: SessionFrontmatter;
+    result: string | undefined;
+}
+export declare function readCompletion(sessionFilePath: string): SessionCompletion;
+export declare function reconcileSessionFile(sessionFilePath: string, now?: Date): SessionCompletion;
+export declare function readPidStartTime(pid: number): string | null;
+export interface SessionRecord {
+    path: string;
+    frontmatter: SessionFrontmatter;
+}
+export declare function listSessionRecords(sessionsDir: string): SessionRecord[];
+export declare function findNewestSessionFile(dir: string): string | undefined;
+export declare function serializeFrontmatter(frontmatter: SessionFrontmatter): string;
+export declare function parseFrontmatter(block: string): SessionFrontmatter;