aimux-cli 0.1.19 → 0.1.20

package/README.md

@@ -374,15 +374,24 @@ For simulator-local development, the helper scripts use `http://127.0.0.1:43191`
 for iOS and `http://10.0.2.2:43191` for Android. For mobile use against a remote
 machine, set `EXPO_PUBLIC_AIMUX_DAEMON_URL=http://<machine>:43190` in `app/.env`.
 
-Release pipeline (uses EAS):
+Release pipeline (uses the shared `@tradersamwise/eas-release` CLI). Two paths,
+chosen by what changed — always bump the version first, then ship:
 
 ```bash
 cd app
-yarn version:bump-build   # new native build
-yarn build:testflight     # EAS build → TestFlight
-yarn update               # OTA JS-only update (testflight channel)
+# OTA update — JavaScript / asset changes only
+yarn version:bump-ota && yarn update              # testflight
+yarn version:bump-ota && yarn update:production   # production
+
+# Native build — native deps, Expo plugins, permissions, icons, splash, native config
+yarn version:bump-build && yarn build:testflight   # testflight
+yarn version:bump-build && yarn build:production    # production
 ```
 
+OTA covers JS and assets; a native rebuild is required for anything that changes
+the native binary or its Expo runtime fingerprint. `bump-ota` aborts if the runtime
+changed since the last native build (an OTA can only target the installed runtime).
+
 ## Tmux Compatibility
 
 Aimux treats tmux as a managed runtime, not a transparent pass-through. For aimux-owned tmux sessions, aimux applies a fixed compatibility contract instead of inheriting whatever ambient tmux defaults happen to exist on the machine.

package/bin/aimux

@@ -1,2 +1,6 @@
 #!/usr/bin/env node
+import { prepareStableCliEnv } from "../dist/launcher-env.js";
+
+prepareStableCliEnv();
+
 import("../dist/main.js");

package/bin/aimux-dev

@@ -1,10 +1,6 @@
 #!/usr/bin/env node
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { prepareDevCliEnv } from "../dist/launcher-env.js";
 
-process.env.AIMUX_HOME ||= join(homedir(), ".aimux-dev");
-process.env.AIMUX_DAEMON_PORT ||= "43191";
-process.env.AIMUX_ENV ||= "development";
-process.env.AIMUX_WEB_APP_URL ||= "http://localhost:8081";
+prepareDevCliEnv();
 
 import("../dist/main.js");

package/dist/agent-output-parser-audit.d.ts

@@ -0,0 +1,23 @@
+export declare const PARSER_AUDIT_FINDING_FLAGS: readonly ["prompt-from-response-record", "raw-block", "status-leak-response", "activity-status-leak", "action-status-leak"];
+export type ParserAuditFindingFlag = (typeof PARSER_AUDIT_FINDING_FLAGS)[number];
+export interface ParserAuditFinding {
+    source: string;
+    recordIndex?: number;
+    tool: string;
+    blockIndex: number;
+    blockType: string;
+    flags: ParserAuditFindingFlag[];
+    sample: string;
+}
+export interface ParserAuditOptions {
+    historyDirs?: string[];
+    contextDirs?: string[];
+    maxFindings?: number;
+    flags?: ParserAuditFindingFlag[];
+}
+export interface ParserAuditSummary {
+    scanned: number;
+    findings: ParserAuditFinding[];
+    countsByFlag: Record<ParserAuditFindingFlag, number>;
+}
+export declare function auditAgentOutputParserCorpus(options: ParserAuditOptions): ParserAuditSummary;

package/dist/agent-output-parser-audit.js

@@ -0,0 +1,187 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { parseAgentOutput } from "./agent-output-parser.js";
+export const PARSER_AUDIT_FINDING_FLAGS = [
+    "prompt-from-response-record",
+    "raw-block",
+    "status-leak-response",
+    "activity-status-leak",
+    "action-status-leak",
+];
+const STATUS_LEAK_RESPONSE_PATTERNS = [
+    /(?:^|\n)\s*How is Claude doing this session/i,
+    /(?:^|\n)\s*Starting MCP servers/i,
+    /(?:^|\n)\s*(?:⏵⏵\s*)?bypass permissions/i,
+    /(?:^|\n)\s*(?:⎿\s*)?Running in the background/i,
+    /(?:^|\n)\s*(?:⏺\s*)?Bash\([^)]*terminal-notifier/i,
+    /(?:^|\n)\s*(?:Thiscommandrequiresapproval|Doyouwanttoproceed)/i,
+    /(?:^|\n)\s*(?:│\s*)?>_\s*OpenAI Codex\b/i,
+    /^\s*(?:⏺\s*)?Bash\([^)\n]+\)\s*$/i,
+    /^\s*(?:⏺\s*)?Read\s+\d+\s+files?(?:\s*\([^)\n]*ctrl\+o to expand[^)\n]*\))?\s*$/i,
+];
+const ACTIVITY_STATUS_LEAK_PATTERNS = [
+    /(?:^|\n)\s*(?:[-*✻✽✶]\s+)?[\p{Lu}][\p{L}-]*(?:ed|ing)\b(?:\s+for\s+\d+(?:ms|s|m|h)(?:\s+\d+(?:ms|s|m|h))*(?=$|(?=\s*[·•.)-]))|\s*(?:\.{3}|…)|\s*\([^)]*\b\d+(?:ms|s|m|h)\b[^)]*\))[^\n]*(?=$|\n)/u,
+    /(?:^|\n)\s*(?:•\s*)?Working\s*\(\d+(?:ms|s|m|h)\b[^\n]*\)\s*(?=$|\n)/i,
+    /(?:^|\n)\s*(?:•\s*)?Starting MCP servers\b[^\n]*(?=$|\n)/i,
+];
+const ACTION_STATUS_LEAK_PATTERNS = [
+    /(?:^|\n)\s*(?:•\s*)?Ran\s+(?:aimux|bash|bun|cat|cd|curl|docker|find|gh|git|grep|ls|mkdir|mv|node|npm|pnpm|python3?|rg|rm|sed|sh|tsc|tsx|vitest|yarn)\b(?![^\n]*(?:\.{3}|…|\b(?:was|is|now|earlier)\b))[^\n!?]*(?=$|\n)/i,
+    /(?:^|\n)\s*(?:•|⏺)?\s*(?:Bash|BashOutput|Edit|Explore|Glob|Grep|KillBash|LS|MultiEdit|NotebookEdit|Read|Task|TodoWrite|Update|WebFetch|WebSearch|Write)\s*(?:\([^)\n]*\)|\d+[^\n]*(?:ctrl\+o|to expand)|[^\n]*(?:Running in the background|exit code))\s*(?=$|\n)/i,
+    /(?:^|\n)\s*└\s+[^\n]*(?=$|\n)/,
+];
+const emptyCounts = () => Object.fromEntries(PARSER_AUDIT_FINDING_FLAGS.map((flag) => [flag, 0]));
+const sampleText = (text) => String(text || "").replace(/\s+/g, " ").trim().slice(0, 320);
+const toolForSource = (source) => {
+    const basename = source.split("/").pop() ?? "";
+    if (/^codex[-_]/i.test(basename) || /\/codex[-_]/i.test(source))
+        return "codex";
+    if (/^claude[-_]/i.test(basename) || /\/claude[-_]/i.test(source))
+        return "claude";
+    return "unknown";
+};
+const looksLikePromptLeakFooter = (block) => {
+    if (!block || block.type !== "status")
+        return false;
+    if (/Conversation interrupted/i.test(block.text))
+        return false;
+    if (/(?:^|\n)\s*(?:•\s*)?(?:Working \(\d+(?:ms|s|m|h)|Starting MCP servers)/i.test(block.text))
+        return false;
+    return /(?:^|\n)\s*(?:gpt-[\w.-]+\b|claude\b|⏵⏵\s*bypass permissions|bypass permissions|.*context\)|.*permissions:)/i.test(block.text);
+};
+const promptLeakLooksActionable = (blocks, blockIndex) => {
+    const prompt = blocks[blockIndex];
+    if (!prompt || prompt.text.trim().length < 3)
+        return false;
+    return looksLikePromptLeakFooter(blocks[blockIndex + 1]);
+};
+const rawBlockLooksActionable = (text) => {
+    const lines = String(text || "")
+        .split("\n")
+        .map((line) => line.trim().replace(/^\d+\s+(?:[+-]\s*)?/, ""))
+        .filter(Boolean);
+    if (lines.length === 0)
+        return false;
+    if (lines.every((line) => /^[{}\][(),;:\s]+$/.test(line)))
+        return false;
+    if (lines.every((line) => /^[\d⋮\s:+\-{},()[\];"\u2500-\u257f]+$/.test(line)))
+        return false;
+    if (lines.every((line) => /^[bcdlps-][rwx-]{9}@?\s+\d+\s+\S+\s+\S+\s+\d+\s+\w{3}\s+\d+/i.test(line))) {
+        return false;
+    }
+    return true;
+};
+function* historyCandidates(historyDir) {
+    if (!existsSync(historyDir) || !statSync(historyDir).isDirectory())
+        return;
+    for (const entry of readdirSync(historyDir).filter((name) => name.endsWith(".jsonl")).sort()) {
+        const source = join(historyDir, entry);
+        const tool = toolForSource(source);
+        const lines = readFileSync(source, "utf8").split("\n");
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index]?.trim();
+            if (!line)
+                continue;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (typeof record.content !== "string")
+                continue;
+            if (record.type !== "response")
+                continue;
+            yield {
+                source,
+                recordIndex: index,
+                recordType: String(record.type),
+                tool,
+                content: record.content,
+            };
+        }
+    }
+}
+function* contextCandidates(contextDir) {
+    if (!existsSync(contextDir) || !statSync(contextDir).isDirectory())
+        return;
+    const stack = [contextDir];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        if (!dir)
+            continue;
+        for (const entry of readdirSync(dir).sort()) {
+            const source = join(dir, entry);
+            const stats = statSync(source);
+            if (stats.isDirectory()) {
+                stack.push(source);
+                continue;
+            }
+            if (entry !== "live.md" && entry !== "summary.md")
+                continue;
+            yield {
+                source,
+                tool: toolForSource(source),
+                content: readFileSync(source, "utf8"),
+            };
+        }
+    }
+}
+export function auditAgentOutputParserCorpus(options) {
+    const findings = [];
+    const countsByFlag = emptyCounts();
+    let scanned = 0;
+    const maxFindings = options.maxFindings ?? Number.POSITIVE_INFINITY;
+    const candidates = [
+        ...(options.historyDirs ?? []).flatMap((dir) => Array.from(historyCandidates(dir))),
+        ...(options.contextDirs ?? []).flatMap((dir) => Array.from(contextCandidates(dir))),
+    ];
+    for (const candidate of candidates) {
+        scanned += 1;
+        const parsed = parseAgentOutput(candidate.content, { tool: candidate.tool });
+        parsed.blocks.forEach((block, blockIndex) => {
+            const flags = [];
+            if (block.type === "raw" && rawBlockLooksActionable(block.text)) {
+                flags.push("raw-block");
+            }
+            if (block.type === "response" && STATUS_LEAK_RESPONSE_PATTERNS.some((pattern) => pattern.test(block.text))) {
+                flags.push("status-leak-response");
+            }
+            if (block.type === "response" && ACTIVITY_STATUS_LEAK_PATTERNS.some((pattern) => pattern.test(block.text))) {
+                flags.push("activity-status-leak");
+            }
+            if (block.type === "response" && ACTION_STATUS_LEAK_PATTERNS.some((pattern) => pattern.test(block.text))) {
+                flags.push("action-status-leak");
+            }
+            if (candidate.recordType === "response" &&
+                block.type === "prompt" &&
+                promptLeakLooksActionable(parsed.blocks, blockIndex)) {
+                flags.push("prompt-from-response-record");
+            }
+            if (options.flags && options.flags.length > 0) {
+                for (let index = flags.length - 1; index >= 0; index -= 1) {
+                    if (!options.flags.includes(flags[index])) {
+                        flags.splice(index, 1);
+                    }
+                }
+            }
+            if (flags.length === 0)
+                return;
+            for (const flag of flags) {
+                countsByFlag[flag] += 1;
+            }
+            if (findings.length >= maxFindings)
+                return;
+            findings.push({
+                source: candidate.source,
+                recordIndex: candidate.recordIndex,
+                tool: parsed.parser.tool,
+                blockIndex,
+                blockType: block.type,
+                flags,
+                sample: sampleText(block.text),
+            });
+        });
+    }
+    return { scanned, findings, countsByFlag };
+}

package/dist/agent-output-parser-contract.d.ts

@@ -0,0 +1,9 @@
+import type { AgentOutputBlockType } from "./agent-output-parser.js";
+export interface AgentOutputParserContract {
+    readonly blockTypes: ReadonlyArray<{
+        readonly type: AgentOutputBlockType;
+        readonly description: string;
+    }>;
+    readonly invariants: readonly string[];
+}
+export declare const AGENT_OUTPUT_PARSER_CONTRACT: AgentOutputParserContract;

package/dist/agent-output-parser-contract.js

@@ -0,0 +1,33 @@
+export const AGENT_OUTPUT_PARSER_CONTRACT = {
+    blockTypes: [
+        {
+            type: "prompt",
+            description: "User-authored input that was actually delivered to the agent.",
+        },
+        {
+            type: "response",
+            description: "Assistant-authored conversational output intended for chat history.",
+        },
+        {
+            type: "status",
+            description: "Transient runtime UI, progress, active input, suggestions, footers, or control-plane output.",
+        },
+        {
+            type: "meta",
+            description: "Startup chrome and non-conversational session metadata.",
+        },
+        {
+            type: "raw",
+            description: "Unclassified terminal text retained for diagnostics until a parser rule can classify it.",
+        },
+    ],
+    invariants: [
+        "Suggested prompts and active input placeholders must not become prompt blocks.",
+        "Feedback/rating prompts must not become prompt blocks.",
+        "A prompt block must represent user text that was submitted to the agent, not text merely visible in the terminal input row.",
+        "Assistant text stays response text even when it contains prompt-looking markers, quotes, bullets, fences, or paths.",
+        "Startup banners, footer/status lines, progress rows, and permission hints must not become response blocks.",
+        "Activity/progress rows must remain status text with their exact activity wording preserved.",
+        "Parsing the same complete transcript repeatedly should produce the same block sequence.",
+    ],
+};

package/dist/agent-output-parser-fixtures.d.ts

@@ -0,0 +1,15 @@
+import type { AgentOutputBlockType } from "./agent-output-parser.js";
+export interface AgentOutputParserFixture {
+    name: string;
+    tool: "claude" | "codex";
+    raw: string;
+    expected: Array<{
+        type: AgentOutputBlockType;
+        includes: string[];
+        excludes?: string[];
+    }>;
+    invariants?: {
+        noPromptIncludes?: string[];
+    };
+}
+export declare const AGENT_OUTPUT_PARSER_FIXTURES: AgentOutputParserFixture[];