aimux-cli 0.1.16 → 0.1.19

package/dist/attachment-store.js

@@ -1,46 +1,6 @@
-import { createHash } from "node:crypto";
-import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
-import { basename, extname, join } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
 import { getAttachmentsDir } from "./paths.js";
-const MIME_BY_EXT = {
-    ".png": "image/png",
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-    ".bmp": "image/bmp",
-    ".svg": "image/svg+xml",
-};
-export function ingestAttachmentFromPath(path) {
-    const trimmedPath = path.trim();
-    if (!trimmedPath) {
-        throw new Error("attachment path is required");
-    }
-    const buffer = readFileSync(trimmedPath);
-    const filename = basename(trimmedPath) || "image";
-    return writeAttachment(buffer, {
-        filename,
-        mimeType: inferMimeType(filename),
-        source: "path",
-    });
-}
-export function ingestAttachmentFromBase64(input) {
-    const contentBase64 = input.contentBase64.trim();
-    if (!contentBase64) {
-        throw new Error("contentBase64 is required");
-    }
-    const buffer = Buffer.from(contentBase64, "base64");
-    if (buffer.length === 0) {
-        throw new Error("attachment content is empty");
-    }
-    const filename = input.filename?.trim() || "image";
-    const mimeType = input.mimeType?.trim() || inferMimeType(filename);
-    return writeAttachment(buffer, {
-        filename,
-        mimeType,
-        source: "upload",
-    });
-}
 export function getAttachment(id) {
     const record = loadAttachmentRecord(id);
     return record ? toPublicAttachment(record) : null;
@@ -55,36 +15,6 @@ export function getAttachmentContent(id) {
         buffer: readFileSync(record.contentPath),
     };
 }
-export function resolveAttachmentPath(id) {
-    const record = loadAttachmentRecord(id);
-    return record?.contentPath ?? null;
-}
-function writeAttachment(buffer, input) {
-    ensureAttachmentsDir();
-    const sha256 = createHash("sha256").update(buffer).digest("hex");
-    const id = `att_${sha256.slice(0, 16)}`;
-    const extension = normalizeExtension(extname(input.filename), input.mimeType);
-    const contentPath = join(getAttachmentsDir(), `${id}${extension}`);
-    const metadataPath = join(getAttachmentsDir(), `${id}.json`);
-    if (!existsSync(contentPath)) {
-        writeFileSync(contentPath, buffer);
-    }
-    const record = {
-        id,
-        kind: "image",
-        filename: input.filename,
-        mimeType: input.mimeType,
-        sizeBytes: buffer.length,
-        sha256,
-        createdAt: existsSync(metadataPath)
-            ? loadAttachmentRecord(id)?.createdAt || new Date().toISOString()
-            : new Date().toISOString(),
-        source: input.source,
-        contentPath,
-    };
-    writeFileSync(metadataPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
-    return toPublicAttachment(record);
-}
 function loadAttachmentRecord(id) {
     const normalizedId = id.trim();
     if (!normalizedId)
@@ -112,18 +42,3 @@ function toPublicAttachment(record) {
         contentUrl: `/attachments/${record.id}/content`,
     };
 }
-function ensureAttachmentsDir() {
-    mkdirSync(getAttachmentsDir(), { recursive: true });
-}
-function inferMimeType(filename) {
-    return MIME_BY_EXT[extname(filename).toLowerCase()] || "application/octet-stream";
-}
-function normalizeExtension(extension, mimeType) {
-    const trimmed = extension.trim().toLowerCase();
-    if (trimmed) {
-        return trimmed;
-    }
-    const matched = Object.entries(MIME_BY_EXT).find(([, candidateMime]) => candidateMime === mimeType)?.[0];
-    return matched || "";
-}
-//# sourceMappingURL=attachment-store.js.map

package/dist/builtin-metadata-watchers.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, watch } from "node:fs";
-import { basename, join } from "node:path";
-import { getPlansDir, getStatusDir, getTasksDir, getHistoryDir } from "./paths.js";
+import { basename, dirname, join } from "node:path";
+import { getPlansDir, getStatusDir, getHistoryDir, getRuntimeExchangePath } from "./paths.js";
 import { debug } from "./debug.js";
 import { readAllTasks } from "./tasks.js";
 import { listSessionIds, readHistory } from "./context/history.js";
@@ -92,7 +92,7 @@ export function createBuiltinMetadataWatchers(api) {
             }
         }
     });
-    const taskWatcher = new DirectoryWatcher(getTasksDir(), () => {
+    const taskWatcher = new DirectoryWatcher(dirname(getRuntimeExchangePath()), () => {
         const tasks = readAllTasks();
         const latestBySession = new Map();
         for (const task of tasks) {
@@ -110,8 +110,8 @@ export function createBuiltinMetadataWatchers(api) {
             latestBySession.set(sessionId, { message: `${prefix}: ${task.description}`, tone });
         }
         for (const [sessionId, entry] of latestBySession) {
-            metadata.log(sessionId, entry.message, { source: "tasks", tone: entry.tone });
             if (lastTaskBySession.get(sessionId) !== entry.message) {
+                metadata.log(sessionId, entry.message, { source: "tasks", tone: entry.tone });
                 if (taskWatcherPrimed) {
                     metadata.emitEvent(sessionId, {
                         kind: entry.tone === "error" ? "task_failed" : entry.tone === "success" ? "task_done" : "task_assigned",
@@ -175,4 +175,3 @@ export function createBuiltinMetadataWatchers(api) {
     debug("registered builtin metadata watchers", "plugin");
     return [planWatcher, statusWatcher, taskWatcher, historyWatcher];
 }
-//# sourceMappingURL=builtin-metadata-watchers.js.map

package/dist/claude-hooks.d.ts

@@ -9,6 +9,7 @@ export interface ClaudeHookPayload {
 }
 export declare function getAimuxCliEntryPath(): string;
 export declare function shouldSkipClaudeSessionIdInjection(args: string[]): boolean;
+export declare function extractClaudeBackendSessionIdFromArgs(args: string[]): string | undefined;
 export declare function buildClaudeHookSettings(opts: {
     sessionId: string;
     projectRoot: string;

package/dist/claude-hooks.js

@@ -13,6 +13,31 @@ export function shouldSkipClaudeSessionIdInjection(args) {
         arg === "--continue" ||
         arg === "-c");
 }
+function isUsableSessionIdArg(value) {
+    return Boolean(value?.trim() && !value.trim().startsWith("-"));
+}
+export function extractClaudeBackendSessionIdFromArgs(args) {
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--session-id" && isUsableSessionIdArg(args[i + 1])) {
+            return args[i + 1].trim();
+        }
+        if (arg.startsWith("--session-id=")) {
+            const value = arg.slice("--session-id=".length);
+            if (isUsableSessionIdArg(value))
+                return value.trim();
+        }
+        if (arg === "--resume" && isUsableSessionIdArg(args[i + 1])) {
+            return args[i + 1].trim();
+        }
+        if (arg.startsWith("--resume=")) {
+            const value = arg.slice("--resume=".length);
+            if (isUsableSessionIdArg(value))
+                return value.trim();
+        }
+    }
+    return undefined;
+}
 function buildClaudeHookCommand(action, sessionId, projectRoot) {
     return [
         shellQuote(process.execPath),
@@ -103,4 +128,3 @@ export function summarizeClaudeStop(payload) {
     const body = pickString(payload.message, object["summary"], object["message"]) ?? "Claude completed its turn.";
     return { subtitle, body };
 }
-//# sourceMappingURL=claude-hooks.js.map

package/dist/config.d.ts

@@ -25,29 +25,33 @@ export interface StatuslineConfig {
     };
 }
 export interface RuntimeConfig {
-    /** Whether aimux injects automatic session preamble / kickoff instructions. */
+    /** Whether aimux injects automatic session preamble instructions. */
     agentPreambleEnabled: boolean;
     tmux: TmuxRuntimeConfig;
 }
+export type LogLevel = "error" | "warn" | "info" | "debug" | "trace";
+export interface LoggingConfig {
+    enabled: boolean;
+    level: LogLevel;
+    /** Category names to include. "*" includes all categories. */
+    categories: string[];
+    /** Rotate the active log file after it reaches this size. */
+    maxBytes: number;
+    /** Number of rotated log files to keep. */
+    maxFiles: number;
+}
 export interface AimuxConfig {
     defaultTool: string;
     contextMaxEntries: number;
     liveWindowSize: number;
     compactEveryNTurns: number;
+    logging: LoggingConfig;
     notifications: NotificationConfig;
     statusline: StatuslineConfig;
     runtime: RuntimeConfig;
     worktrees: WorktreeConfig;
     tools: Record<string, ToolConfig>;
 }
-export interface SessionCaptureConfig {
-    /** Directory to watch for new files. Supports {home}, {yyyy}, {mm}, {dd} */
-    dir: string;
-    /** Regex to extract session ID from filename */
-    pattern: string;
-    /** Delay before first check in ms */
-    delayMs: number;
-}
 export interface ToolConfig {
     command: string;
     args: string[];
@@ -67,10 +71,10 @@ export interface ToolConfig {
     resumeFallback?: string[];
     /** Flag to set a session ID when starting, with {sessionId} placeholder, e.g. ["--session-id", "{sessionId}"] */
     sessionIdFlag?: string[];
-    /** How to capture backend session ID when sessionIdFlag isn't available */
-    sessionCapture?: SessionCaptureConfig;
-    /** File to write preamble instructions to (created on start, removed on exit), e.g. "AGENTS.md" */
+    /** Optional file to write preamble instructions to; disabled by default to avoid surprise repo edits. */
     instructionsFile?: string;
+    /** Codex config key used for durable standing instructions, e.g. "developer_instructions" */
+    developerInstructionsConfigKey?: string | null;
     /** Regex patterns that indicate the tool is idle/waiting for input */
     promptPatterns?: string[];
     /** Regex patterns to detect user prompts in terminal output (for turn extraction) */
@@ -82,7 +86,9 @@ export interface ToolConfig {
  * Load config with hierarchy: defaults → global (~/.aimux/config.json) → project (.aimux/config.json)
  * Project settings override global, global overrides defaults.
  */
-export declare function loadConfig(): AimuxConfig;
+export declare function loadConfig(opts?: {
+    includeGlobal?: boolean;
+}): AimuxConfig;
 /** Save config to project-level .aimux/config.json */
 export declare function saveConfig(config: AimuxConfig): void;
 /** Save config to global ~/.aimux/config.json */

package/dist/config.js

@@ -6,6 +6,13 @@ const DEFAULT_CONFIG = {
     contextMaxEntries: 20,
     liveWindowSize: 20,
     compactEveryNTurns: 50,
+    logging: {
+        enabled: false,
+        level: "info",
+        categories: ["*"],
+        maxBytes: 10_000_000,
+        maxFiles: 5,
+    },
     notifications: {
         enabled: true,
         onPrompt: true,
@@ -38,7 +45,7 @@ const DEFAULT_CONFIG = {
             preambleFlag: ["--append-system-prompt"],
             sessionIdFlag: ["--session-id", "{sessionId}"],
             resumeArgs: ["--resume", "{sessionId}"],
-            resumeByBackendSessionId: false,
+            resumeByBackendSessionId: true,
             resumeFallback: ["--continue"],
             promptPatterns: ["^> $", "\\$ $"],
             turnPatterns: ["^[❯>]\\s*(.+)", "^❯\\s+(.+)", "^>\\s+(.+)"],
@@ -51,12 +58,7 @@ const DEFAULT_CONFIG = {
             resumeArgs: ["resume", "{sessionId}"],
             resumeByBackendSessionId: true,
             resumeFallback: ["resume", "--last"],
-            instructionsFile: "AGENTS.md",
-            sessionCapture: {
-                dir: "{home}/.codex/sessions/{yyyy}/{mm}/{dd}",
-                pattern: "([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\\.jsonl$",
-                delayMs: 2000,
-            },
+            developerInstructionsConfigKey: "developer_instructions",
             promptPatterns: ["^> $"],
             turnPatterns: ["^[>❯]\\s*(.+)"],
         },
@@ -73,15 +75,30 @@ const DEFAULT_CONFIG = {
 function cloneJson(value) {
     return JSON.parse(JSON.stringify(value));
 }
+function hasSessionPlaceholder(args) {
+    return Boolean(args?.some((arg) => arg.includes("{sessionId}")));
+}
+function normalizeConfig(config) {
+    const claude = config.tools.claude;
+    if (claude?.command === "claude" &&
+        hasSessionPlaceholder(claude.sessionIdFlag) &&
+        hasSessionPlaceholder(claude.resumeArgs)) {
+        // Current Claude Code supports pairing --session-id with --resume <id>.
+        // Treat older generated configs that set this false as stale rather than
+        // silently launching a fresh Claude under an existing aimux row.
+        claude.resumeByBackendSessionId = true;
+    }
+    return config;
+}
 /**
  * Load config with hierarchy: defaults → global (~/.aimux/config.json) → project (.aimux/config.json)
  * Project settings override global, global overrides defaults.
  */
-export function loadConfig() {
+export function loadConfig(opts = {}) {
     let config = cloneJson(DEFAULT_CONFIG);
     // Layer 1: global config
     const globalPath = getGlobalConfigPath();
-    if (existsSync(globalPath)) {
+    if (opts.includeGlobal !== false && existsSync(globalPath)) {
         try {
             const globalRaw = JSON.parse(readFileSync(globalPath, "utf-8"));
             config = deepMerge(config, globalRaw);
@@ -97,7 +114,7 @@ export function loadConfig() {
         }
         catch { }
     }
-    return config;
+    return normalizeConfig(config);
 }
 /** Save config to project-level .aimux/config.json */
 export function saveConfig(config) {
@@ -115,11 +132,8 @@ export function saveGlobalConfig(config) {
     }
     writeFileSync(getGlobalConfigPath(), JSON.stringify(config, null, 2) + "\n");
 }
-const GITIGNORE_CONTENTS = `# Runtime-private session state (lives in ~/.aimux/projects/)
+const GITIGNORE_CONTENTS = `# Runtime-private service/project state (lives in ~/.aimux/projects/)
 state.json
-graveyard.json
-sessions.json
-instances.json
 
 # Agent-facing shared artifacts
 context/
@@ -178,4 +192,3 @@ function deepMerge(a, b) {
     }
     return result;
 }
-//# sourceMappingURL=config.js.map

package/dist/connection-targets.d.ts

@@ -0,0 +1,8 @@
+export declare function isDevelopmentRuntime(): boolean;
+export declare function resolveWebAppUrl(override?: string): string;
+export declare function resolveRelayUrl(): string;
+export declare const CONNECTION_TARGET_DEFAULTS: {
+    readonly prodWebAppUrl: "https://aimux.app";
+    readonly prodRelayUrl: "wss://relay.aimux.app";
+    readonly devWebAppUrl: "http://localhost:8081";
+};

package/dist/connection-targets.js

@@ -0,0 +1,27 @@
+const PROD_WEB_APP_URL = "https://aimux.app";
+const PROD_RELAY_URL = "wss://relay.aimux.app";
+const DEV_WEB_APP_URL = "http://localhost:8081";
+function cleanUrl(value) {
+    return value.replace(/\/$/, "");
+}
+function optionalEnv(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+export function isDevelopmentRuntime() {
+    return process.env.AIMUX_ENV === "development";
+}
+export function resolveWebAppUrl(override) {
+    const value = optionalEnv(override) ??
+        optionalEnv(process.env.AIMUX_WEB_APP_URL) ??
+        (isDevelopmentRuntime() ? DEV_WEB_APP_URL : PROD_WEB_APP_URL);
+    return cleanUrl(value);
+}
+export function resolveRelayUrl() {
+    return cleanUrl(optionalEnv(process.env.AIMUX_RELAY_URL) ?? PROD_RELAY_URL);
+}
+export const CONNECTION_TARGET_DEFAULTS = {
+    prodWebAppUrl: PROD_WEB_APP_URL,
+    prodRelayUrl: PROD_RELAY_URL,
+    devWebAppUrl: DEV_WEB_APP_URL,
+};

package/dist/context/compactor.js

@@ -209,4 +209,3 @@ function truncate(text, max) {
         return text;
     return text.slice(0, max) + "...";
 }
-//# sourceMappingURL=compactor.js.map

package/dist/context/context-bridge.js

@@ -475,4 +475,3 @@ function truncate(text, max) {
         return text;
     return text.slice(0, max) + "...";
 }
-//# sourceMappingURL=context-bridge.js.map

package/dist/context/context-file.js

@@ -90,4 +90,3 @@ export function readContext(maxEntries = 20) {
         return "";
     return selected.join("");
 }
-//# sourceMappingURL=context-file.js.map

package/dist/context/history.js

@@ -105,4 +105,3 @@ export function readAllHistories(sessionIds, opts) {
     all.sort((a, b) => (a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0));
     return all;
 }
-//# sourceMappingURL=history.js.map

package/dist/credentials.d.ts

@@ -0,0 +1,12 @@
+export interface AimuxCredentials {
+    version: 1;
+    relayUrl: string;
+    token: string;
+    userId: string;
+    createdAt: string;
+    remoteEnabled: boolean;
+}
+export declare function loadCredentials(): AimuxCredentials | null;
+export declare function saveCredentials(creds: AimuxCredentials): void;
+export declare function clearCredentials(): "cleared" | "none" | "failed";
+export declare function setRemoteEnabled(enabled: boolean): AimuxCredentials | null;

package/dist/credentials.js

@@ -0,0 +1,48 @@
+// Stored CLI credentials for relay access (`~/.aimux/auth.json`).
+//
+// Populated by `aimux login` (browser flow). The daemon reads this to connect
+// to the relay. The token is a long-lived relay-signed JWT — not a Clerk
+// session token — so it survives daemon restarts and runs for ~90 days.
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, chmodSync } from "node:fs";
+import { dirname } from "node:path";
+import { getAuthPath } from "./paths.js";
+export function loadCredentials() {
+    const path = getAuthPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (parsed.version !== 1 || !parsed.token || !parsed.relayUrl)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveCredentials(creds) {
+    const path = getAuthPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(creds, null, 2)}\n`, { mode: 0o600 });
+    chmodSync(path, 0o600);
+}
+export function clearCredentials() {
+    const path = getAuthPath();
+    if (!existsSync(path))
+        return "none";
+    try {
+        rmSync(path, { force: true });
+    }
+    catch {
+        return "failed";
+    }
+    return "cleared";
+}
+export function setRemoteEnabled(enabled) {
+    const creds = loadCredentials();
+    if (!creds)
+        return null;
+    const next = { ...creds, remoteEnabled: enabled };
+    saveCredentials(next);
+    return next;
+}

package/dist/daemon.d.ts

@@ -1,3 +1,6 @@
+import { type RelayStatusSnapshot } from "./relay-client.js";
+export declare function getDaemonHost(): string;
+export declare function getDaemonPort(): number;
 export interface AimuxDaemonInfo {
     pid: number;
     port: number;
@@ -26,14 +29,34 @@ export declare function stopProjectService(projectRoot: string): Promise<Project
 export declare function projectServiceStatus(projectRoot: string): Promise<ProjectServiceState | null>;
 export declare class AimuxDaemon {
     private server;
+    private relayClient;
     private readonly children;
+    private readonly projectEnsurePromises;
     private state;
     start(): Promise<void>;
+    private connectRelayIfConfigured;
+    getRelayStatus(): RelayStatusSnapshot | {
+        status: "off";
+    };
+    enableRelay(): RelayStatusSnapshot | {
+        status: "off";
+    };
+    disableRelay(): {
+        status: "off";
+    };
     stop(): void;
     private refreshState;
     private spawnProjectService;
     private ensureProject;
+    private ensureProjectUnlocked;
+    private replaceProjectServiceAfterExit;
+    private terminateProjectService;
+    private waitForProjectServiceExit;
     private stopProject;
+    routeRequest(method: string, path: string, body?: unknown, headers?: Record<string, string>): Promise<{
+        status: number;
+        body: unknown;
+    }>;
     private handle;
 }
 export {};