@getmikie/cli 1.1.87 → 1.1.89

package/README.md

@@ -16,3 +16,18 @@ mikie mcp
 The launcher contains no relay, pricing, receipt, or model logic. npm installs
 the matching `@getmikie/*` optional platform package and the launcher executes that
 binary with inherited stdio.
+
+## Mikie Control
+
+Run one immutable, repository-scoped request through the verified Codex App
+Server runtime:
+
+```sh
+mikie control run --request C:\absolute\path\control-request.json --json
+```
+
+The request must be an existing absolute JSON file. Mikie validates the frozen
+repository, allowed paths, deterministic verifier, exact model and reasoning
+effort, bounded model-turn timeout, and private temporary root before execution. The JSON result is
+content-free: it reports terminal status and hashes, never prompts, context,
+patch bodies, verifier output, or credentials.

package/bin/mikie.mjs

@@ -9,6 +9,7 @@ import { fileURLToPath } from "node:url";
 import {
   launchNativeCaptured,
   launchNative,
+  prepareNativeLaunch,
   resolveNativeBinary,
   selectPlatformPackage,
   translateArguments,
@@ -38,6 +39,7 @@ Usage:
   mikie mcp [--adapter codex|claude_code]
   mikie login
   mikie connect .
+  mikie control run --request <absolute-json> --json
   mikie doctor
   mikie update
 
@@ -183,8 +185,11 @@ All commands execute the compiled Mikie native engine.`);
   }
 } else {
   try {
-    const binary = await resolveNativeBinary();
-    process.exitCode = await launchNative(binary, translateArguments(arguments_));
+    const nativeArguments = translateArguments(arguments_);
+    const binary = await prepareNativeLaunch(await resolveNativeBinary(), nativeArguments, {
+      version: packageMetadata.version,
+    });
+    process.exitCode = await launchNative(binary, nativeArguments);
   } catch (error) {
     const message = error instanceof Error ? error.message : "Mikie is unavailable";
     console.error(`mikie: ${message}`);

package/lib/launcher.mjs

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
-import { access, stat } from "node:fs/promises";
-import { constants as fsConstants } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { constants as fsConstants, createReadStream } from "node:fs";
+import { access, copyFile, lstat, mkdir, readdir, rename, rm, stat } from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
 
@@ -18,6 +19,142 @@ const SIGNAL_EXIT_CODES = new Map([
 ]);
 
 const MAX_CAPTURED_OUTPUT_BYTES = 1024 * 1024;
+const SAFE_RUNTIME_VERSION = /^[0-9A-Za-z][0-9A-Za-z._-]{0,127}$/;
+const SAFE_RUNTIME_DIRECTORY = /^[0-9A-Za-z][0-9A-Za-z._-]{0,127}-[0-9a-f]{64}$/;
+const HISTORICAL_RUNTIME_GRACE_MS = 24 * 60 * 60 * 1000;
+
+async function sha256File(file) {
+  const digest = createHash("sha256");
+  for await (const chunk of createReadStream(file)) {
+    digest.update(chunk);
+  }
+  return digest.digest("hex");
+}
+
+async function verifyMaterializedRuntime(file, expectedSha256, { allowMissing = false } = {}) {
+  try {
+    const metadata = await lstat(file);
+    if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size === 0) {
+      throw new Error("Mikie cached Windows runtime is invalid");
+    }
+    if ((await sha256File(file)) !== expectedSha256) {
+      throw new Error("Mikie cached Windows runtime hash does not match");
+    }
+    return true;
+  } catch (error) {
+    if (allowMissing && error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+async function cleanupHistoricalWindowsRuntimes(runtimeRoot, selectedDirectory) {
+  let entries;
+  try {
+    entries = await readdir(runtimeRoot, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - HISTORICAL_RUNTIME_GRACE_MS;
+  await Promise.all(
+    entries.map(async (entry) => {
+      if (
+        !entry.isDirectory() ||
+        entry.name === selectedDirectory ||
+        !SAFE_RUNTIME_DIRECTORY.test(entry.name)
+      ) {
+        return;
+      }
+      const candidate = path.join(runtimeRoot, entry.name);
+      try {
+        if ((await lstat(candidate)).mtimeMs > cutoff) return;
+        await rm(candidate, { recursive: true, force: true, maxRetries: 0 });
+      } catch {
+        // Active Windows executables remain locked and are retried by a later launch.
+      }
+    }),
+  );
+}
+
+export function shouldStageWindowsRuntime(arguments_) {
+  if (arguments_.length === 0) return true;
+  if (["mcp", "serve", "run-relay"].includes(arguments_[0])) return true;
+  return arguments_[0] === "control" && arguments_[1] === "run";
+}
+
+export async function materializeWindowsRuntime(
+  binary,
+  { version, localAppData = process.env.LOCALAPPDATA } = {},
+) {
+  if (
+    !path.isAbsolute(binary) ||
+    !path.isAbsolute(localAppData ?? "") ||
+    !SAFE_RUNTIME_VERSION.test(version ?? "")
+  ) {
+    throw new Error("Mikie cached Windows runtime authority is invalid");
+  }
+  const sourceMetadata = await lstat(binary);
+  if (!sourceMetadata.isFile() || sourceMetadata.isSymbolicLink() || sourceMetadata.size === 0) {
+    throw new Error("Mikie native Windows runtime is invalid");
+  }
+  const sourceSha256 = await sha256File(binary);
+  const runtimeRoot = path.join(localAppData, "Mikie", "runtime-v1");
+  const selectedDirectory = `${version}-${sourceSha256}`;
+  const runtimeDirectory = path.join(runtimeRoot, selectedDirectory);
+  const materialized = path.join(runtimeDirectory, "mikie.exe");
+  await mkdir(runtimeDirectory, { recursive: true });
+  if (await verifyMaterializedRuntime(materialized, sourceSha256, { allowMissing: true })) {
+    await cleanupHistoricalWindowsRuntimes(runtimeRoot, selectedDirectory);
+    return materialized;
+  }
+
+  const temporary = path.join(
+    runtimeDirectory,
+    `.mikie-${process.pid}-${randomUUID()}.tmp`,
+  );
+  try {
+    await copyFile(binary, temporary, fsConstants.COPYFILE_EXCL);
+    const [copiedSha256, stableSourceSha256] = await Promise.all([
+      sha256File(temporary),
+      sha256File(binary),
+    ]);
+    if (copiedSha256 !== sourceSha256 || stableSourceSha256 !== sourceSha256) {
+      throw new Error("Mikie native Windows runtime changed during materialization");
+    }
+    try {
+      await rename(temporary, materialized);
+    } catch (error) {
+      if (
+        !["EEXIST", "EPERM"].includes(error?.code) ||
+        !(await verifyMaterializedRuntime(materialized, sourceSha256, { allowMissing: true }))
+      ) {
+        throw error;
+      }
+    }
+    await verifyMaterializedRuntime(materialized, sourceSha256);
+    await cleanupHistoricalWindowsRuntimes(runtimeRoot, selectedDirectory);
+    return materialized;
+  } finally {
+    await rm(temporary, { force: true }).catch(() => {});
+  }
+}
+
+export async function prepareNativeLaunch(
+  binary,
+  arguments_,
+  {
+    platform = process.platform,
+    version,
+    environment = process.env,
+  } = {},
+) {
+  if (platform !== "win32" || !shouldStageWindowsRuntime(arguments_)) {
+    return binary;
+  }
+  return materializeWindowsRuntime(binary, {
+    version,
+    localAppData: environment.LOCALAPPDATA,
+  });
+}
 
 function currentRuntimeUsesGlibc() {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getmikie/cli",
-  "version": "1.1.87",
+  "version": "1.1.89",
   "description": "Native Mikie relay launcher for MCP clients",
   "license": "Apache-2.0",
   "repository": {
@@ -20,10 +20,10 @@
     "node": ">=22"
   },
   "optionalDependencies": {
-    "@getmikie/darwin-arm64": "1.1.87",
-    "@getmikie/darwin-x64": "1.1.87",
-    "@getmikie/linux-x64-gnu": "1.1.87",
-    "@getmikie/win32-x64": "1.1.87"
+    "@getmikie/darwin-arm64": "1.1.89",
+    "@getmikie/darwin-x64": "1.1.89",
+    "@getmikie/linux-x64-gnu": "1.1.89",
+    "@getmikie/win32-x64": "1.1.89"
   },
   "publishConfig": {
     "access": "public",