@meego-harness/mara-worker 0.8.0

package/dist/index.d.ts

@@ -0,0 +1,232 @@
+import { WorkerClientSDK, Part } from '@meego-harness/worker-sdk';
+import { Buffer } from 'node:buffer';
+import { SpawnOptions, ChildProcess, SpawnSyncReturns, spawnSync } from 'node:child_process';
+
+type PermissionPreset = 'safe' | 'default' | 'full-access';
+type MiraReasoningEffort = 'low' | 'medium' | 'high' | 'xhigh';
+type MiraReasoningEffortSelection = 'use-mira-default' | 'use-coco-default' | MiraReasoningEffort;
+type MiraModelSelection = 'use-mira-default' | 'use-coco-default' | (string & {});
+interface MiraWorkerConfig {
+    serverUrl: string;
+    email: string;
+    workerId: string;
+    capabilitySummary: string;
+    defaultWorkspace: string;
+    repoMappings: Record<string, string>;
+    enabled: boolean;
+    permissionPreset: PermissionPreset;
+    modelSelection: MiraModelSelection;
+    reasoningEffortDefault: MiraReasoningEffortSelection;
+}
+interface MiraWorkerSetupResult extends MiraWorkerConfig {
+}
+type MiraWorkerSetupInput = Partial<MiraWorkerConfig>;
+interface MiraWorkerContextBinding {
+    contextId: string;
+    repo?: string;
+    cwd: string;
+    sessionId?: string;
+    reasoningEffort?: MiraReasoningEffort;
+    planMode: boolean;
+}
+interface MiraWorkerState {
+    contexts: MiraWorkerContextBinding[];
+}
+interface MiraWorkerBridgeConfig extends MiraWorkerConfig {
+    stateFile?: string;
+    reconnectBaseDelayMs?: number;
+    reconnectMaxDelayMs?: number;
+}
+interface MiraWorkerBridgeLogger {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+interface MiraCliTaskExecutionRequest {
+    taskId: string;
+    contextId: string;
+    cwd: string;
+    prompt: string;
+    sessionId?: string;
+    model?: string;
+    reasoningEffort?: MiraReasoningEffort;
+    permissionPreset: PermissionPreset;
+    abortSignal: AbortSignal;
+    env?: Record<string, string>;
+}
+interface MiraCliTaskExecutionResult {
+    text: string;
+    sessionId: string;
+}
+interface MiraTaskExecutor {
+    runTurn: (request: MiraCliTaskExecutionRequest) => Promise<MiraCliTaskExecutionResult>;
+}
+interface MiraWorkerBridgeDependencies {
+    executor: MiraTaskExecutor;
+    logger: MiraWorkerBridgeLogger;
+    client?: WorkerClientSDK;
+}
+interface MiraWorkerPrompter {
+    text: (params: {
+        message: string;
+        placeholder?: string;
+        initialValue?: string;
+        validate?: (value: string) => string | undefined;
+    }) => Promise<string>;
+    select: (params: {
+        message: string;
+        options: Array<{
+            value: string;
+            label: string;
+        }>;
+        initialValue?: string;
+    }) => Promise<string>;
+    confirm: (params: {
+        message: string;
+        initialValue?: boolean;
+    }) => Promise<boolean>;
+}
+interface RunMiraWorkerSetupDependencies {
+    homeDir?: string;
+    logger: MiraWorkerBridgeLogger;
+}
+interface MiraWorkerListItem extends MiraWorkerConfig {
+    configFile: string;
+    stateFile: string;
+}
+interface MiraWorkerDoctorWorkerReport extends MiraWorkerListItem {
+    configStatus: 'ok' | 'error';
+    runtimeStatus: 'ok' | 'error';
+    errors: string[];
+}
+interface MiraWorkerDoctorReport {
+    workers: MiraWorkerDoctorWorkerReport[];
+}
+interface ResolveStoragePathsOptions {
+    homeDir?: string;
+}
+interface MiraCliTaskExecutorConfig {
+    miraBin?: string;
+    pythonBin?: string;
+    runnerScript?: string;
+    spawn?: (command: string, args: string[], options: SpawnOptions) => ChildProcess;
+    spawnSync?: (command: string, args: string[], options: {
+        encoding?: BufferEncoding;
+        stdio?: 'ignore';
+    }) => SpawnSyncReturns<string | Buffer>;
+}
+type CocoReasoningEffort = MiraReasoningEffort;
+type CocoReasoningEffortSelection = MiraReasoningEffortSelection;
+type CocoModelSelection = MiraModelSelection;
+type CocoWorkerConfig = MiraWorkerConfig;
+type CocoWorkerSetupResult = MiraWorkerSetupResult;
+type CocoWorkerSetupInput = MiraWorkerSetupInput;
+type CocoWorkerContextBinding = MiraWorkerContextBinding;
+type CocoWorkerState = MiraWorkerState;
+type CocoWorkerBridgeConfig = MiraWorkerBridgeConfig;
+type CocoWorkerBridgeLogger = MiraWorkerBridgeLogger;
+type CocoCliTaskExecutionRequest = MiraCliTaskExecutionRequest;
+type CocoCliTaskExecutionResult = MiraCliTaskExecutionResult;
+type CocoTaskExecutor = MiraTaskExecutor;
+type CocoWorkerBridgeDependencies = MiraWorkerBridgeDependencies;
+type CocoWorkerPrompter = MiraWorkerPrompter;
+type RunCocoWorkerSetupDependencies = RunMiraWorkerSetupDependencies;
+type CocoWorkerListItem = MiraWorkerListItem;
+type CocoWorkerDoctorWorkerReport = MiraWorkerDoctorWorkerReport;
+type CocoWorkerDoctorReport = MiraWorkerDoctorReport;
+type CocoCliTaskExecutorConfig = MiraCliTaskExecutorConfig;
+
+declare class CocoWorkerBridge {
+    private readonly config;
+    private readonly executor;
+    private readonly logger;
+    private readonly client;
+    private readonly activeTasks;
+    private readonly pendingCanceledTaskIds;
+    private readonly bindings;
+    private readonly contextQueues;
+    private readonly stateFile;
+    constructor(config: CocoWorkerBridgeConfig, dependencies: CocoWorkerBridgeDependencies);
+    start(): Promise<this>;
+    stop(): Promise<void>;
+    private handleTaskMessage;
+    private processTaskMessage;
+    private trySendTaskStatusUpdate;
+    private handleTaskCancel;
+    private createBinding;
+    private hydrateBindingFromMetadata;
+    private resolveCwd;
+    private ensureDirectory;
+    private persistState;
+    private isTaskCanceled;
+    private resolveStructuredProjectNodeResult;
+}
+
+declare function resolveMiraWorkerStorageDir(options?: ResolveStoragePathsOptions): string;
+declare function resolveMiraWorkerConfigFile(workerId: string, options?: ResolveStoragePathsOptions): string;
+declare function resolveMiraWorkerStateFile(workerId: string, options?: ResolveStoragePathsOptions): string;
+declare function loadMiraWorkerConfig(workerId: string, options?: ResolveStoragePathsOptions): MiraWorkerConfig;
+declare function writeMiraWorkerConfig(config: MiraWorkerConfig, options?: ResolveStoragePathsOptions): void;
+declare function loadMiraWorkerState(stateFile: string): MiraWorkerState;
+declare function writeMiraWorkerState(stateFile: string, state: MiraWorkerState): void;
+declare function runMiraWorkerSetup(dependencies: RunMiraWorkerSetupDependencies, prompter: MiraWorkerPrompter, input?: MiraWorkerSetupInput): Promise<MiraWorkerSetupResult>;
+declare function listMiraWorkerConfigs(options?: ResolveStoragePathsOptions): MiraWorkerListItem[];
+declare function getMiraWorkerDoctorReport(options?: ResolveStoragePathsOptions, dependencies?: {
+    assertCocoCliAvailable?: () => void;
+}): MiraWorkerDoctorReport;
+declare function setMiraWorkerEnabled(workerId: string, enabled: boolean, options?: ResolveStoragePathsOptions): void;
+declare function uninstallMiraWorker(workerId: string, options?: ResolveStoragePathsOptions): {
+    configFile: string;
+    stateFile: string;
+    credentialFile: string | undefined;
+    removedConfig: boolean;
+    removedState: boolean;
+    removedCredential: boolean;
+};
+declare function createClackPrompter(): MiraWorkerPrompter;
+declare const resolveCocoWorkerStorageDir: typeof resolveMiraWorkerStorageDir;
+declare const resolveCocoWorkerConfigFile: typeof resolveMiraWorkerConfigFile;
+declare const resolveCocoWorkerStateFile: typeof resolveMiraWorkerStateFile;
+declare const loadCocoWorkerConfig: typeof loadMiraWorkerConfig;
+declare const writeCocoWorkerConfig: typeof writeMiraWorkerConfig;
+declare const loadCocoWorkerState: typeof loadMiraWorkerState;
+declare const writeCocoWorkerState: typeof writeMiraWorkerState;
+declare const runCocoWorkerSetup: typeof runMiraWorkerSetup;
+declare const listCocoWorkerConfigs: typeof listMiraWorkerConfigs;
+declare const getCocoWorkerDoctorReport: typeof getMiraWorkerDoctorReport;
+declare const setCocoWorkerEnabled: typeof setMiraWorkerEnabled;
+declare const uninstallCocoWorker: typeof uninstallMiraWorker;
+
+declare const MIRA_WORKER_ROLE = "coder";
+declare const MIRA_WORKER_WORKING_TEXT = "Mira CLI is working";
+declare const MIRA_WORKER_CONFIG_DIR = ".meego-harness/mara-worker";
+declare const COCO_WORKER_ROLE = "coder";
+declare const COCO_WORKER_WORKING_TEXT = "Mira CLI is working";
+declare const COCO_WORKER_CONFIG_DIR = ".meego-harness/mara-worker";
+
+declare function stringifyTaskMessageParts(parts: Part[]): string;
+
+declare class MiraCliTaskExecutor {
+    private readonly miraBin;
+    private readonly pythonBin;
+    private readonly runnerScript;
+    private readonly spawnChild;
+    constructor(config?: MiraCliTaskExecutorConfig);
+    runTurn(request: MiraCliTaskExecutionRequest): Promise<MiraCliTaskExecutionResult>;
+}
+declare function assertMiraCliAvailable(miraBin?: string, run?: typeof spawnSync, pythonBin?: string): void;
+declare function buildMiraPayload(request: MiraCliTaskExecutionRequest): {
+    cwd: string;
+    prompt: string;
+    session_id: string | undefined;
+    model: string | undefined;
+    reasoning_effort: MiraReasoningEffort | undefined;
+    permission_preset: PermissionPreset;
+    disable_remote_capabilities: boolean;
+};
+declare function createAbortError(): Error;
+declare function isAbortError(error: unknown): boolean;
+declare const CocoCliTaskExecutor: typeof MiraCliTaskExecutor;
+declare const assertCocoCliAvailable: typeof assertMiraCliAvailable;
+
+export { COCO_WORKER_CONFIG_DIR, COCO_WORKER_ROLE, COCO_WORKER_WORKING_TEXT, type CocoCliTaskExecutionRequest, type CocoCliTaskExecutionResult, CocoCliTaskExecutor, type CocoCliTaskExecutorConfig, type CocoModelSelection, type CocoReasoningEffort, type CocoReasoningEffortSelection, type CocoTaskExecutor, CocoWorkerBridge, type CocoWorkerBridgeConfig, type CocoWorkerBridgeDependencies, type CocoWorkerBridgeLogger, type CocoWorkerConfig, type CocoWorkerContextBinding, type CocoWorkerDoctorReport, type CocoWorkerDoctorWorkerReport, type CocoWorkerListItem, type CocoWorkerPrompter, type CocoWorkerSetupInput, type CocoWorkerSetupResult, type CocoWorkerState, MIRA_WORKER_CONFIG_DIR, MIRA_WORKER_ROLE, MIRA_WORKER_WORKING_TEXT, type MiraCliTaskExecutionRequest, type MiraCliTaskExecutionResult, MiraCliTaskExecutor, type MiraCliTaskExecutorConfig, type MiraModelSelection, type MiraReasoningEffort, type MiraReasoningEffortSelection, type MiraTaskExecutor, CocoWorkerBridge as MiraWorkerBridge, type MiraWorkerBridgeConfig, type MiraWorkerBridgeDependencies, type MiraWorkerBridgeLogger, type MiraWorkerConfig, type MiraWorkerContextBinding, type MiraWorkerDoctorReport, type MiraWorkerDoctorWorkerReport, type MiraWorkerListItem, type MiraWorkerPrompter, type MiraWorkerSetupInput, type MiraWorkerSetupResult, type MiraWorkerState, type PermissionPreset, type ResolveStoragePathsOptions, type RunCocoWorkerSetupDependencies, type RunMiraWorkerSetupDependencies, assertCocoCliAvailable, assertMiraCliAvailable, buildMiraPayload, createAbortError, createClackPrompter, getCocoWorkerDoctorReport, getMiraWorkerDoctorReport, isAbortError, listCocoWorkerConfigs, listMiraWorkerConfigs, loadCocoWorkerConfig, loadCocoWorkerState, loadMiraWorkerConfig, loadMiraWorkerState, resolveCocoWorkerConfigFile, resolveCocoWorkerStateFile, resolveCocoWorkerStorageDir, resolveMiraWorkerConfigFile, resolveMiraWorkerStateFile, resolveMiraWorkerStorageDir, runCocoWorkerSetup, runMiraWorkerSetup, setCocoWorkerEnabled, setMiraWorkerEnabled, stringifyTaskMessageParts, uninstallCocoWorker, uninstallMiraWorker, writeCocoWorkerConfig, writeCocoWorkerState, writeMiraWorkerConfig, writeMiraWorkerState };

package/dist/index.js

@@ -0,0 +1,86 @@
+import {
+  COCO_WORKER_CONFIG_DIR,
+  COCO_WORKER_ROLE,
+  COCO_WORKER_WORKING_TEXT,
+  CocoCliTaskExecutor,
+  CocoWorkerBridge,
+  MIRA_WORKER_CONFIG_DIR,
+  MIRA_WORKER_ROLE,
+  MIRA_WORKER_WORKING_TEXT,
+  MiraCliTaskExecutor,
+  assertCocoCliAvailable,
+  assertMiraCliAvailable,
+  buildMiraPayload,
+  createAbortError,
+  createClackPrompter,
+  getCocoWorkerDoctorReport,
+  getMiraWorkerDoctorReport,
+  isAbortError,
+  listCocoWorkerConfigs,
+  listMiraWorkerConfigs,
+  loadCocoWorkerConfig,
+  loadCocoWorkerState,
+  loadMiraWorkerConfig,
+  loadMiraWorkerState,
+  resolveCocoWorkerConfigFile,
+  resolveCocoWorkerStateFile,
+  resolveCocoWorkerStorageDir,
+  resolveMiraWorkerConfigFile,
+  resolveMiraWorkerStateFile,
+  resolveMiraWorkerStorageDir,
+  runCocoWorkerSetup,
+  runMiraWorkerSetup,
+  setCocoWorkerEnabled,
+  setMiraWorkerEnabled,
+  stringifyTaskMessageParts,
+  uninstallCocoWorker,
+  uninstallMiraWorker,
+  writeCocoWorkerConfig,
+  writeCocoWorkerState,
+  writeMiraWorkerConfig,
+  writeMiraWorkerState
+} from "./chunk-VUPAW5X2.js";
+export {
+  COCO_WORKER_CONFIG_DIR,
+  COCO_WORKER_ROLE,
+  COCO_WORKER_WORKING_TEXT,
+  CocoCliTaskExecutor,
+  CocoWorkerBridge,
+  MIRA_WORKER_CONFIG_DIR,
+  MIRA_WORKER_ROLE,
+  MIRA_WORKER_WORKING_TEXT,
+  MiraCliTaskExecutor,
+  CocoWorkerBridge as MiraWorkerBridge,
+  assertCocoCliAvailable,
+  assertMiraCliAvailable,
+  buildMiraPayload,
+  createAbortError,
+  createClackPrompter,
+  getCocoWorkerDoctorReport,
+  getMiraWorkerDoctorReport,
+  isAbortError,
+  listCocoWorkerConfigs,
+  listMiraWorkerConfigs,
+  loadCocoWorkerConfig,
+  loadCocoWorkerState,
+  loadMiraWorkerConfig,
+  loadMiraWorkerState,
+  resolveCocoWorkerConfigFile,
+  resolveCocoWorkerStateFile,
+  resolveCocoWorkerStorageDir,
+  resolveMiraWorkerConfigFile,
+  resolveMiraWorkerStateFile,
+  resolveMiraWorkerStorageDir,
+  runCocoWorkerSetup,
+  runMiraWorkerSetup,
+  setCocoWorkerEnabled,
+  setMiraWorkerEnabled,
+  stringifyTaskMessageParts,
+  uninstallCocoWorker,
+  uninstallMiraWorker,
+  writeCocoWorkerConfig,
+  writeCocoWorkerState,
+  writeMiraWorkerConfig,
+  writeMiraWorkerState
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -0,0 +1,218 @@
+{
+  "name": "@meego-harness/mara-worker",
+  "type": "module",
+  "version": "0.8.0",
+  "description": "Standalone Mira CLI worker bridge for meego-harness WorkerServerSDK",
+  "license": "MIT",
+  "keywords": [
+    "meego-harness-worker",
+    "mira"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "meego-mara-worker": "./bin/meego-mara-worker.mjs"
+  },
+  "files": [
+    "README.md",
+    "bin",
+    "dist",
+    "python"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.2.0",
+    "zod": "^4.3.6",
+    "@meego-harness/manager-contract": "^0.8.0",
+    "@meego-harness/prompt-registry": "^0.8.0",
+    "@meego-harness/worker-sdk": "^0.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.39",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.1.12",
+    "vitest": "^4.1.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "meegoHarnessWorker": {
+    "schemaVersion": 1,
+    "id": "mara-worker",
+    "displayName": "Mara Worker",
+    "description": "Mira CLI worker bridge",
+    "installStrategy": "private-package",
+    "runtimeKind": "foreground-process",
+    "capabilities": [
+      "setup",
+      "list",
+      "doctor",
+      "start",
+      "stop",
+      "uninstall"
+    ],
+    "prerequisites": [
+      {
+        "type": "command",
+        "command": "mira -v",
+        "reason": "Mira CLI must be installed"
+      }
+    ],
+    "setupFields": [
+      "defaultWorkspace",
+      "permissionPreset",
+      "model",
+      "reasoningEffort"
+    ],
+    "setupFieldDefaults": {
+      "permissionPreset": "default",
+      "model": "use-mira-default",
+      "reasoningEffort": "use-mira-default"
+    },
+    "setupFieldOptions": {
+      "permissionPreset": [
+        {
+          "value": "safe",
+          "label": "safe"
+        },
+        {
+          "value": "default",
+          "label": "default"
+        },
+        {
+          "value": "full-access",
+          "label": "full-access"
+        }
+      ],
+      "model": [
+        {
+          "value": "use-mira-default",
+          "label": "use-mira-default"
+        },
+        {
+          "value": "use-coco-default",
+          "label": "use-coco-default"
+        },
+        {
+          "value": "opus4.6t",
+          "label": "opus4.6t"
+        }
+      ],
+      "reasoningEffort": [
+        {
+          "value": "use-mira-default",
+          "label": "use-mira-default"
+        },
+        {
+          "value": "use-coco-default",
+          "label": "use-coco-default"
+        },
+        {
+          "value": "low",
+          "label": "low"
+        },
+        {
+          "value": "medium",
+          "label": "medium"
+        },
+        {
+          "value": "high",
+          "label": "high"
+        },
+        {
+          "value": "xhigh",
+          "label": "xhigh"
+        }
+      ]
+    },
+    "quickStartTemplates": [
+      {
+        "id": "default",
+        "displayName": "Default options",
+        "description": "Use default Mira options",
+        "setupFieldValues": {
+          "permissionPreset": "default",
+          "model": "use-mira-default",
+          "reasoningEffort": "use-mira-default"
+        }
+      },
+      {
+        "id": "full-access-latest",
+        "displayName": "Full access latest",
+        "description": "Use full access with the latest Mira model",
+        "setupFieldValues": {
+          "permissionPreset": "full-access",
+          "model": "opus4.6t",
+          "reasoningEffort": "xhigh"
+        }
+      }
+    ],
+    "actions": {
+      "setup": {
+        "runner": "package-bin",
+        "executable": "meego-mara-worker",
+        "args": [
+          "setup",
+          "--json"
+        ]
+      },
+      "list": {
+        "runner": "package-bin",
+        "executable": "meego-mara-worker",
+        "args": [
+          "list",
+          "--json"
+        ]
+      },
+      "doctor": {
+        "runner": "package-bin",
+        "executable": "meego-mara-worker",
+        "args": [
+          "doctor",
+          "--json"
+        ]
+      },
+      "start": {
+        "runner": "package-bin",
+        "executable": "meego-mara-worker",
+        "args": [
+          "start",
+          "--worker",
+          "{{workerId}}"
+        ]
+      },
+      "stop": {
+        "runner": "package-bin",
+        "executable": "meego-mara-worker",
+        "args": [
+          "stop",
+          "--worker",
+          "{{workerId}}"
+        ]
+      },
+      "uninstall": {
+        "runner": "package-bin",
+        "executable": "meego-mara-worker",
+        "args": [
+          "uninstall",
+          "--worker",
+          "{{workerId}}"
+        ]
+      }
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/python/mira_worker_runner.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+
+import importlib.util
+import io
+import json
+import os
+import sys
+import traceback
+from contextlib import redirect_stderr, redirect_stdout
+
+
+def load_mira_module():
+    script_path = os.path.expanduser("~/.mira/mira.py")
+    if not os.path.isfile(script_path):
+        raise FileNotFoundError(f"Mira Python entrypoint not found: {script_path}")
+
+    spec = importlib.util.spec_from_file_location("meego_mira_worker_runtime", script_path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Unable to load Mira module from {script_path}")
+
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def resolve_model_key(module, raw_model, reasoning_effort):
+    if raw_model and raw_model not in ("use-mira-default", "use-coco-default"):
+        normalized = str(raw_model).strip()
+        lowered = normalized.lower()
+        if normalized in module.MODELS:
+            return normalized
+        if lowered in module.MODEL_ALIASES:
+            return module.MODEL_ALIASES[lowered]
+        return normalized
+
+    if reasoning_effort in ("high", "xhigh"):
+        return "opus4.6t"
+
+    return module.DEFAULT_MODEL
+
+
+def extract_text(messages):
+    for message in reversed(messages):
+        if message.get("role") != "assistant":
+            continue
+        content = message.get("content", [])
+        if isinstance(content, list):
+          texts = []
+          for block in content:
+              if isinstance(block, dict) and block.get("type") == "text":
+                  texts.append(block.get("text", ""))
+          text = "".join(texts).strip()
+          if text:
+              return text
+        elif isinstance(content, str):
+          text = content.strip()
+          if text:
+              return text
+    return ""
+
+
+def main():
+    try:
+        request = json.load(sys.stdin)
+        cwd = request["cwd"]
+        prompt = request["prompt"]
+        session_id = request.get("session_id") or ""
+        model = request.get("model")
+        reasoning_effort = request.get("reasoning_effort")
+        permission_preset = request.get("permission_preset", "default")
+        disable_remote_capabilities = bool(request.get("disable_remote_capabilities", True))
+
+        os.chdir(cwd)
+        module = load_mira_module()
+
+        if disable_remote_capabilities:
+            module.MiraClient.fetch_tool_list = lambda self: []
+            module.MiraClient.fetch_skill_list = lambda self: []
+
+        cli = module.MiraCLI()
+        if not cli.config.has_auth:
+            raise RuntimeError("Mira is not logged in. Run `mira login` first.")
+
+        cli.config._raw_config["auto_start_bridge"] = False
+        cli.config.model_key = resolve_model_key(module, model, reasoning_effort)
+        cli.mcp = None
+        cli.client = module.MiraClient(cli.config, None)
+        cli.executor = module.ToolExecutor(None, cli.client._mcp_tools_for_api, None)
+
+        if session_id:
+            cli.client.load_conversation(session_id)
+
+        original_execute = cli.executor.execute
+
+        def guarded_execute(name, inp):
+            if permission_preset == "safe" and name in ("write_file", "edit_file"):
+                return ("Permission preset safe blocks file mutations in Mira worker mode", True)
+            return original_execute(name, inp)
+
+        cli.executor.execute = guarded_execute
+
+        captured = io.StringIO()
+        with redirect_stdout(captured), redirect_stderr(captured):
+            cli.run_turn(prompt)
+            cli.client.save_conversation()
+
+        text = extract_text(cli.client.messages)
+        if not text:
+            captured_output = captured.getvalue().strip()
+            raise RuntimeError(
+                "Mira did not produce assistant text."
+                + (f" Captured output: {captured_output[-1000:]}" if captured_output else "")
+            )
+
+        print(json.dumps({
+            "text": text,
+            "sessionId": cli.client.conv_id,
+            "miraSessionId": cli.client.mira_session_id,
+        }))
+    except Exception as error:
+        print(json.dumps({
+            "error": str(error),
+            "traceback": traceback.format_exc(limit=5),
+        }))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()