@aspectlylabs/mikka 0.0.0-stage → 0.0.1

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "@aspectlylabs/mikka",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "description": "Local Mikka daemon: runs agents through the user's own CLIs",
+  "type": "module",
+  "private": false,
+  "license": "AGPL-3.0-only",
+  "engines": {
+    "node": ">=24"
+  },
+  "bin": {
+    "mikka": "./mikka.js"
+  },
+  "exports": {
+    ".": "./main.js",
+    "./cli": "./cli.js",
+    "./client": "./client.js",
+    "./env": "./env.js",
+    "./paths": "./paths.js",
+    "./http-link": "./http-link.js",
+    "./login": "./login.js",
+    "./log": "./log.js",
+    "./sandbox": "./sandbox.js",
+    "./coordinator": "./coordinator.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alexj11324/Mikka.git",
+    "directory": "packages/daemon"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "1.9.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.305",
+    "@anthropic-ai/sandbox-runtime": "0.0.80",
+    "ai": "7.0.142",
+    "execa": "10.1.1",
+    "pino": "10.4.0",
+    "proper-lockfile": "4.1.2",
+    "rotating-file-stream": "3.2.10",
+    "simple-git": "4.0.2",
+    "vscode-jsonrpc": "9.0.3",
+    "zod": "4.6.7"
+  }
+}

package/paths.js

@@ -0,0 +1,108 @@
+// src/paths.ts
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// package.json
+var package_default = {
+  name: "@mikka/daemon",
+  version: "0.0.1",
+  description: "Local Mikka daemon: runs agents through the user's own CLIs",
+  type: "module",
+  private: true,
+  license: "AGPL-3.0-only",
+  bin: {
+    mikka: "./dist/mikka.js"
+  },
+  exports: {
+    ".": "./src/main.ts",
+    "./cli": "./src/cli.ts",
+    "./client": "./src/rpc/client.ts",
+    "./env": "./src/env.ts",
+    "./paths": "./src/paths.ts",
+    "./http-link": "./src/server-link-http.ts",
+    "./login": "./src/login.ts",
+    "./log": "./src/log.ts",
+    "./sandbox": "./src/agents/sandbox.ts",
+    "./coordinator": "./src/coordinator/index.ts"
+  },
+  scripts: {
+    daemon: "tsx bin/mikka.ts daemon",
+    dev: "tsx watch bin/mikka.ts daemon --dev --server memory",
+    typecheck: "tsgo --noEmit -p tsconfig.json",
+    test: "vitest run && pnpm test:mailbox-cli && pnpm test:repository-identity",
+    "test:mailbox-cli": "node --import tsx --test --test-timeout=60000 test/run-mailbox.node-test.ts",
+    "codex:types": 'codex app-server generate-ts --out "${TMPDIR:-/tmp}/mikka-codex-types" && echo "Generated; compare v2/ with src/adapters/codex-protocol.ts"',
+    "test:real": "MIKKA_REAL_AGENTS=${MIKKA_REAL_AGENTS:-claude_code,codex,cursor} vitest run test/real-agents.test.ts",
+    "test:changed": "vitest run --changed origin/main --passWithNoTests",
+    build: "node scripts/build.mjs",
+    "test:package": "node --test test/package.test.mjs",
+    "test:repository-identity": "node --experimental-strip-types --test test/repository-identity-pure.node-test.ts"
+  },
+  dependencies: {
+    "@agentclientprotocol/sdk": "1.9.0",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.305",
+    "@anthropic-ai/sandbox-runtime": "0.0.80",
+    "@mikka/protocol": "workspace:*",
+    ai: "7.0.142",
+    execa: "10.1.1",
+    pino: "10.4.0",
+    "proper-lockfile": "4.1.2",
+    "rotating-file-stream": "3.2.10",
+    "simple-git": "4.0.2",
+    "vscode-jsonrpc": "9.0.3",
+    zod: "4.6.7"
+  },
+  devDependencies: {
+    "@mikka/config": "workspace:*",
+    "@types/node": "24.19.2",
+    "@types/proper-lockfile": "4.1.4",
+    tsx: "4.23.15",
+    esbuild: "0.28.2",
+    vitest: "5.0.5"
+  },
+  engines: {
+    node: ">=24"
+  }
+};
+
+// src/paths.ts
+var DAEMON_VERSION = package_default.version;
+function productName(flavor) {
+  return flavor === "dev" ? "Mikka Dev" : "Mikka";
+}
+function defaultDataDir(flavor, env = process.env, platform = process.platform) {
+  if (flavor === "dev" && env.MIKKA_USER_DATA_DIR) {
+    return env.MIKKA_USER_DATA_DIR;
+  }
+  const home = env.HOME || homedir();
+  const base = platform === "darwin" ? join(home, "Library", "Application Support") : platform === "win32" ? env.APPDATA || join(home, "AppData", "Roaming") : env.XDG_CONFIG_HOME || join(home, ".config");
+  const dir = join(base, productName(flavor));
+  const legacy = join(base, legacyProductName(flavor));
+  return !existsSync(dir) && existsSync(legacy) ? legacy : dir;
+}
+function legacyProductName(flavor) {
+  return flavor === "dev" ? "Orvilo Dev" : "Orvilo";
+}
+function daemonPaths(dataDir) {
+  return {
+    dataDir,
+    socket: join(dataDir, "daemon.sock"),
+    lock: join(dataDir, "daemon.lock"),
+    secret: join(dataDir, "daemon.secret"),
+    device: join(dataDir, "device.json"),
+    journal: join(dataDir, "runs.json"),
+    outbox: join(dataDir, "outbox"),
+    worktrees: join(dataDir, "worktrees"),
+    repos: join(dataDir, "repos"),
+    adapterState: join(dataDir, "adapters"),
+    logs: join(dataDir, "logs"),
+    devRepos: join(dataDir, "dev-repos.json")
+  };
+}
+export {
+  DAEMON_VERSION,
+  daemonPaths,
+  defaultDataDir,
+  productName
+};

package/sandbox.js

@@ -0,0 +1,133 @@
+// src/agents/sandbox.ts
+import { randomBytes } from "node:crypto";
+import { SandboxManager } from "@anthropic-ai/sandbox-runtime";
+import { execa } from "execa";
+function shellQuote(arg) {
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(arg)) return arg;
+  return `'${arg.replaceAll("'", `'"'"'`)}'`;
+}
+function shellJoin(argv) {
+  return argv.map(shellQuote).join(" ");
+}
+var SandboxRuntime = class _SandboxRuntime {
+  constructor(onAsk) {
+    this.onAsk = onAsk;
+  }
+  onAsk;
+  kind = "sandbox-runtime";
+  static owner = null;
+  ready = null;
+  resetting = null;
+  /** The platform is supported and its tools (Linux: bwrap, socat, rg) exist. */
+  static supported() {
+    return SandboxManager.isSupportedPlatform() && SandboxManager.checkDependencies().errors.length === 0;
+  }
+  /** Check that the runtime can actually start isolation on this host. */
+  async probe() {
+    const wrapped = await this.wrap(["/bin/sh", "-c", ":"], {
+      allowWrite: [],
+      allowDomains: []
+    });
+    try {
+      const result = await execa("/bin/sh", ["-c", wrapped.command], {
+        reject: false,
+        timeout: 1e4
+      });
+      if (result.failed) {
+        throw new Error(
+          `sandbox probe failed: ${result.timedOut ? "timed out" : result.stderr.trim() || `exit ${result.exitCode}`}`
+        );
+      }
+    } finally {
+      wrapped.release();
+    }
+  }
+  init() {
+    if (this.resetting) return Promise.reject(new Error("sandbox runtime is stopping"));
+    if (this.ready) return this.ready;
+    if (_SandboxRuntime.owner && _SandboxRuntime.owner !== this) {
+      return Promise.reject(new Error("sandbox runtime is already in use by another instance"));
+    }
+    _SandboxRuntime.owner = this;
+    this.ready = SandboxManager.initialize(
+      {
+        // Everything is per run (`registerCommandNetworkLists`).
+        network: { allowedDomains: [], deniedDomains: [] },
+        filesystem: { denyRead: [], allowWrite: [], denyWrite: [] },
+        // Rust and Go CLIs (codex) verify TLS through trustd; without it
+        // every HTTPS request from them fails inside the sandbox.
+        enableWeakerNetworkIsolation: true
+      },
+      async ({ host, port }) => await this.onAsk?.({ host, port }) === true
+    ).catch(async (error) => {
+      await SandboxManager.reset().catch(() => void 0);
+      _SandboxRuntime.owner = null;
+      this.ready = null;
+      throw error;
+    });
+    return this.ready;
+  }
+  async wrap(argv, policy) {
+    await this.init();
+    const commandId = randomBytes(16).toString("base64url");
+    const command = await SandboxManager.wrapWithSandbox(
+      shellJoin(argv),
+      "/bin/sh",
+      {
+        filesystem: {
+          denyRead: policy.denyRead ?? [],
+          allowWrite: policy.allowWrite,
+          denyWrite: policy.denyWrite ?? []
+        }
+      },
+      void 0,
+      { commandId }
+    );
+    SandboxManager.registerCommandNetworkLists(commandId, {
+      allowedDomains: policy.allowDomains
+    });
+    let released = false;
+    return {
+      command,
+      annotate: (stderr) => SandboxManager.annotateStderrWithSandboxFailures(commandId, stderr),
+      release() {
+        if (released) return;
+        released = true;
+        SandboxManager.unregisterCommandNetworkLists(commandId);
+      }
+    };
+  }
+  /** Stops the proxy; the next `wrap` starts it again. */
+  reset() {
+    if (this.resetting) return this.resetting;
+    if (_SandboxRuntime.owner !== this) return Promise.resolve();
+    this.resetting = (async () => {
+      try {
+        await this.ready?.catch(() => void 0);
+        if (_SandboxRuntime.owner === this) await SandboxManager.reset();
+      } finally {
+        if (_SandboxRuntime.owner === this) _SandboxRuntime.owner = null;
+        this.ready = null;
+        this.resetting = null;
+      }
+    })();
+    return this.resetting;
+  }
+};
+var NoSandbox = class {
+  kind = "none";
+  async wrap(argv) {
+    return {
+      command: `exec ${shellJoin(argv)}`,
+      annotate: (stderr) => stderr,
+      release() {
+      }
+    };
+  }
+};
+export {
+  NoSandbox,
+  SandboxRuntime,
+  shellJoin,
+  shellQuote
+};