@kafca/agentdock 0.1.44 → 0.1.46

package/dist-electron/services/local-ai-core/src/runtime/standalone.js

@@ -10,8 +10,10 @@ const local_core_controller_js_1 = require("./local-core-controller.js");
 const server_js_1 = require("./server.js");
 async function main() {
     const userDataPath = node_process_1.default.env.AI_WORKSTATION_USER_DATA_DIR?.trim() || (0, node_path_1.join)(node_process_1.default.cwd(), '.agentdock-core');
+    const host = node_process_1.default.env.AI_WORKSTATION_HOST?.trim() || '127.0.0.1';
     (0, node_fs_1.mkdirSync)(userDataPath, { recursive: true });
     const controller = new local_core_controller_js_1.LocalCoreController(userDataPath);
+    const server = new server_js_1.LocalAiCoreServer(controller, { host });
     controller.on('logs', (line) => {
         if (!line) {
             return;
@@ -21,9 +23,8 @@ async function main() {
     controller.on('bridge', (event) => {
         node_process_1.default.stdout.write(`[local-ai-core bridge] ${JSON.stringify(event)}\n`);
     });
-    await controller.init();
-    const server = new server_js_1.LocalAiCoreServer(controller);
     await server.start();
+    await controller.init();
     node_process_1.default.on('SIGINT', async () => {
         await server.stop();
         await controller.close();
@@ -35,4 +36,13 @@ async function main() {
         node_process_1.default.exit(0);
     });
 }
-void main();
+void main().catch((error) => {
+    const code = typeof error === 'object' && error ? error.code : '';
+    if (code === 'EADDRINUSE') {
+        node_process_1.default.stderr.write('[local-ai-core] Port 9831 is already in use; another Local AI Core process is listening.\n');
+        node_process_1.default.exit(0);
+        return;
+    }
+    node_process_1.default.stderr.write(`${error instanceof Error ? error.stack || error.message : String(error)}\n`);
+    node_process_1.default.exit(1);
+});

package/dist-electron/services/local-ai-core/src/sandbox/opensandbox-client.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenSandboxClient = void 0;
+const local_core_errors_js_1 = require("../kernel/local-core-errors.js");
+class OpenSandboxClient {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async health() {
+        return this.request('GET', '/health');
+    }
+    async createSandbox(input) {
+        const response = await this.request('POST', '/v1/sandboxes', {
+            image: {
+                uri: input.image,
+            },
+            entrypoint: input.entrypoint,
+            env: input.env,
+            metadata: input.metadata,
+            volumes: input.volumes.map((volume, index) => ({
+                name: `agentdock-${index + 1}`,
+                host: {
+                    path: volume.host,
+                },
+                mountPath: volume.container,
+                readOnly: volume.mode === 'ro',
+            })),
+            ports: input.ports,
+            timeout: input.timeoutSeconds,
+            timeoutSeconds: input.timeoutSeconds,
+            resourceLimits: {
+                cpu: input.cpu,
+                memory: input.memory,
+            },
+        });
+        const sandbox = response?.sandbox || response?.data || response;
+        const id = String(sandbox?.id || sandbox?.sandboxId || '').trim();
+        if (!id) {
+            throw new local_core_errors_js_1.LocalCoreError('sandbox_start_failed', 'OpenSandbox create response did not include a sandbox id.', {
+                details: { response },
+            });
+        }
+        return { ...sandbox, id };
+    }
+    async getSandbox(sandboxId) {
+        const response = await this.request('GET', `/v1/sandboxes/${encodeURIComponent(sandboxId)}`);
+        const sandbox = response?.sandbox || response?.data || response;
+        return { ...sandbox, id: String(sandbox?.id || sandbox?.sandboxId || sandboxId) };
+    }
+    async getEndpoint(sandboxId, port) {
+        const response = await this.request('GET', `/v1/sandboxes/${encodeURIComponent(sandboxId)}/endpoints/${port}`);
+        const endpoint = String(response?.endpoint || response?.data?.endpoint || response?.url || response?.data?.url || '').trim();
+        if (!endpoint) {
+            throw new local_core_errors_js_1.LocalCoreError('sandbox_endpoint_missing', `OpenSandbox did not return an endpoint for port ${port}.`, {
+                details: { sandboxId, port, response },
+            });
+        }
+        return { ...response, endpoint };
+    }
+    async deleteSandbox(sandboxId) {
+        await this.request('DELETE', `/v1/sandboxes/${encodeURIComponent(sandboxId)}`);
+    }
+    async request(method, path, body) {
+        const fetchImpl = this.options.fetchImpl || fetch;
+        const headers = {
+            accept: 'application/json',
+        };
+        if (body !== undefined) {
+            headers['content-type'] = 'application/json';
+        }
+        if (this.options.apiKey) {
+            headers['OPEN-SANDBOX-API-KEY'] = this.options.apiKey;
+            headers.authorization = `Bearer ${this.options.apiKey}`;
+        }
+        let response;
+        try {
+            response = await fetchImpl(`${this.options.serverUrl}${path}`, {
+                method,
+                headers,
+                body: body === undefined ? undefined : JSON.stringify(body),
+            });
+        }
+        catch (error) {
+            throw new local_core_errors_js_1.LocalCoreError('sandbox_unavailable', `OpenSandbox request failed: ${error instanceof Error ? error.message : String(error)}`, {
+                cause: error instanceof Error ? error.message : String(error),
+                details: { method, path, serverUrl: this.options.serverUrl },
+            });
+        }
+        const text = await response.text();
+        const json = text ? parseJson(text) : {};
+        if (!response.ok) {
+            throw new local_core_errors_js_1.LocalCoreError(response.status === 401 || response.status === 403 ? 'sandbox_unauthorized' : 'sandbox_request_failed', `OpenSandbox ${method} ${path} failed with ${response.status}.`, {
+                details: {
+                    method,
+                    path,
+                    status: response.status,
+                    response: json || text,
+                },
+            });
+        }
+        return (json || {});
+    }
+}
+exports.OpenSandboxClient = OpenSandboxClient;
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}

package/dist-electron/services/local-ai-core/src/sandbox/sandbox-config.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_STATE_MOUNT_PATH = exports.DEFAULT_WORKSPACE_MOUNT_PATH = exports.DEFAULT_SANDBOX_MEMORY = exports.DEFAULT_SANDBOX_CPU = exports.DEFAULT_SANDBOX_WARM_POOL_SIZE = exports.DEFAULT_SANDBOX_IDLE_SECONDS = exports.DEFAULT_SANDBOX_TIMEOUT_SECONDS = exports.DEFAULT_SANDBOX_ACP_PORT = exports.DEFAULT_PI_SANDBOX_IMAGE = exports.DEFAULT_SANDBOX_STATE_HOST_ROOT_ENV = exports.DEFAULT_OPENSANDBOX_API_KEY_ENV = exports.DEFAULT_OPENSANDBOX_SERVER_URL_ENV = exports.DEFAULT_OPENSANDBOX_SERVER_URL = void 0;
+exports.getProjectSandboxOptions = getProjectSandboxOptions;
+exports.isProjectSandboxEnabled = isProjectSandboxEnabled;
+exports.normalizeSandboxLaunchConfig = normalizeSandboxLaunchConfig;
+exports.resolveSandboxStateHostPath = resolveSandboxStateHostPath;
+exports.cleanupRunScopedState = cleanupRunScopedState;
+exports.materializeSandboxLaunchConfig = materializeSandboxLaunchConfig;
+exports.defaultOpenSandboxServerUrl = defaultOpenSandboxServerUrl;
+exports.sandboxProxyScriptPath = sandboxProxyScriptPath;
+exports.resolveSandboxProxyCwd = resolveSandboxProxyCwd;
+exports.sandboxProxyLaunchEnv = sandboxProxyLaunchEnv;
+exports.sanitizePathSegment = sanitizePathSegment;
+exports.resolveHostPathFromConfigDir = resolveHostPathFromConfigDir;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const index_js_1 = require("../../../../packages/contracts/src/index.js");
+exports.DEFAULT_OPENSANDBOX_SERVER_URL = 'http://127.0.0.1:8080';
+exports.DEFAULT_OPENSANDBOX_SERVER_URL_ENV = 'AGENTDOCK_OPENSANDBOX_SERVER_URL';
+exports.DEFAULT_OPENSANDBOX_API_KEY_ENV = 'OPEN_SANDBOX_API_KEY';
+exports.DEFAULT_SANDBOX_STATE_HOST_ROOT_ENV = 'AGENTDOCK_SANDBOX_STATE_HOST_ROOT';
+exports.DEFAULT_PI_SANDBOX_IMAGE = 'agentdock/pi-acp:local';
+exports.DEFAULT_SANDBOX_ACP_PORT = 8080;
+exports.DEFAULT_SANDBOX_TIMEOUT_SECONDS = 7200;
+exports.DEFAULT_SANDBOX_IDLE_SECONDS = 900;
+exports.DEFAULT_SANDBOX_WARM_POOL_SIZE = 0;
+exports.DEFAULT_SANDBOX_CPU = '1000m';
+exports.DEFAULT_SANDBOX_MEMORY = '2Gi';
+exports.DEFAULT_WORKSPACE_MOUNT_PATH = '/workspace';
+exports.DEFAULT_STATE_MOUNT_PATH = '/agent-state';
+function getProjectSandboxOptions(project) {
+    const sandbox = project.agent?.options?.sandbox;
+    return sandbox && typeof sandbox === 'object' ? sandbox : null;
+}
+function isProjectSandboxEnabled(project) {
+    return Boolean(getProjectSandboxOptions(project)?.enabled);
+}
+function normalizeSandboxLaunchConfig(input) {
+    const raw = getProjectSandboxOptions(input.project);
+    if (!raw?.enabled) {
+        return undefined;
+    }
+    const configDir = (0, node_path_1.dirname)(input.configState.path);
+    const userDataRoot = (0, node_path_1.dirname)(configDir);
+    const agentType = input.launchConfig.agentType || String(input.project.agent?.type || '').trim().toLowerCase() || 'agent';
+    const desktopConfig = input.configState.parsed || {};
+    const deploymentProfileId = String(raw.deployment_profile || desktopConfig.deployment_profile || process.env.AGENTDOCK_DEPLOYMENT_PROFILE || '').trim();
+    const profile = (0, index_js_1.getDesktopDeploymentProfile)(deploymentProfileId);
+    const sandboxProvider = resolveSandboxProvider(desktopConfig.sandbox_providers, raw, profile.id);
+    const runtimeImage = resolveSandboxRuntimeImage(desktopConfig.sandbox_runtime_images, raw, agentType);
+    const stateScope = normalizeStateScope(raw.state_scope);
+    const stateMountPath = normalizeAbsoluteContainerPath(raw.state_mount_path || runtimeImage.state_mount_path || profile.stateMountPath, exports.DEFAULT_STATE_MOUNT_PATH);
+    const projectId = sanitizePathSegment(input.project.name, 'project');
+    const rawOptions = input.project.agent?.options || {};
+    const userId = sanitizePathSegment(String(rawOptions.user_id || rawOptions.tenant_id || 'local'), 'local');
+    const agentId = sanitizePathSegment(agentType, 'agent');
+    const stateHostRoot = String(process.env[exports.DEFAULT_SANDBOX_STATE_HOST_ROOT_ENV] || '').trim() || (0, node_path_1.resolve)(userDataRoot, 'sandbox-state');
+    const proxyCwd = resolveSandboxProxyCwd(configDir);
+    const stateHostPath = (0, node_path_1.resolve)(stateHostRoot, 'users', userId, ...(stateScope === 'user'
+        ? ['agents', agentId]
+        : ['projects', projectId, 'agents', agentId]), ...(stateScope === 'thread'
+        ? ['threads', '${LOCAL_AI_THREAD_ID}', 'state']
+        : stateScope === 'run'
+            ? ['runs', '${AGENTDOCK_SANDBOX_RUN_ID}', 'state']
+            : ['state']));
+    if (stateHostPath && !stateHostPath.includes('${')) {
+        (0, node_fs_1.mkdirSync)(stateHostPath, { recursive: true, mode: 0o700 });
+    }
+    return {
+        enabled: true,
+        provider: String(raw.provider || sandboxProvider.type || 'opensandbox').trim() || 'opensandbox',
+        transport: normalizeSandboxTransport(runtimeImage.transport || raw.transport),
+        serverUrl: normalizeServerUrl(sandboxProvider.server_url || raw.server_url || profile.openSandboxServerUrl),
+        apiKeyEnv: String(sandboxProvider.api_key_env || raw.api_key_env || exports.DEFAULT_OPENSANDBOX_API_KEY_ENV).trim() || exports.DEFAULT_OPENSANDBOX_API_KEY_ENV,
+        image: String(runtimeImage.image || raw.image || defaultSandboxImage(agentType)).trim() || defaultSandboxImage(agentType),
+        acpPort: normalizePositiveInteger(runtimeImage.acp_port || raw.acp_port, exports.DEFAULT_SANDBOX_ACP_PORT),
+        entrypoint: normalizeEntrypoint(runtimeImage.entrypoint || raw.entrypoint),
+        timeoutSeconds: normalizePositiveInteger(raw.timeout_seconds, exports.DEFAULT_SANDBOX_TIMEOUT_SECONDS),
+        lifecycle: normalizeSandboxLifecycle(raw.sandbox_lifecycle),
+        idleSeconds: normalizePositiveInteger(raw.idle_seconds, exports.DEFAULT_SANDBOX_IDLE_SECONDS),
+        warmPoolSize: normalizeNonNegativeInteger(raw.warm_pool_size, exports.DEFAULT_SANDBOX_WARM_POOL_SIZE),
+        cpu: String(raw.cpu || exports.DEFAULT_SANDBOX_CPU).trim() || exports.DEFAULT_SANDBOX_CPU,
+        memory: String(raw.memory || exports.DEFAULT_SANDBOX_MEMORY).trim() || exports.DEFAULT_SANDBOX_MEMORY,
+        userId,
+        projectId,
+        stateScope,
+        workspaceHostPath: input.launchConfig.workDir,
+        workspaceMountPath: normalizeAbsoluteContainerPath(raw.workspace_mount_path || runtimeImage.workspace_mount_path || profile.workspaceMountPath, exports.DEFAULT_WORKSPACE_MOUNT_PATH),
+        proxyCwd,
+        stateHostPath,
+        stateMountPath,
+        stateMount: {
+            userId,
+            projectId,
+            agentType,
+            scope: stateScope,
+            hostPath: stateHostPath,
+            containerPath: stateMountPath,
+        },
+        runtimeCommand: normalizeRuntimeCommandForSandbox(agentType, input.launchConfig.command, runtimeImage.runtime_command),
+        runtimeArgs: normalizeRuntimeArgsForSandbox(agentType, input.launchConfig.args || [], runtimeImage.runtime_args),
+        runtimeEnv: normalizeRuntimeEnvForSandbox(agentType, input.launchConfig.env || {}, stateMountPath),
+    };
+}
+function resolveSandboxProvider(providers, raw, profileId) {
+    const providerId = String(raw.provider_id || '').trim();
+    const selected = Array.isArray(providers)
+        ? providers.find((provider) => provider.id === providerId)
+            || providers.find((provider) => provider.id === index_js_1.DEFAULT_SANDBOX_PROVIDER_ID)
+        : undefined;
+    if (selected) {
+        return selected;
+    }
+    if (raw.server_url || raw.api_key_env || raw.provider) {
+        return {
+            id: providerId || index_js_1.DEFAULT_SANDBOX_PROVIDER_ID,
+            type: raw.provider || 'opensandbox',
+            name: 'OpenSandbox',
+            server_url: raw.server_url || defaultOpenSandboxServerUrl(),
+            api_key_env: raw.api_key_env || exports.DEFAULT_OPENSANDBOX_API_KEY_ENV,
+        };
+    }
+    return {
+        ...(0, index_js_1.defaultSandboxProviderForProfile)(profileId),
+        server_url: defaultOpenSandboxServerUrl(),
+    };
+}
+function resolveSandboxRuntimeImage(images, raw, agentType) {
+    const runtimeImageId = String(raw.runtime_image_id || '').trim();
+    const selected = Array.isArray(images)
+        ? images.find((image) => image.id === runtimeImageId)
+            || images.find((image) => image.agent_type === agentType)
+        : undefined;
+    if (selected) {
+        const fallback = (0, index_js_1.defaultSandboxRuntimeImage)(agentType);
+        return {
+            ...selected,
+            transport: normalizeSandboxTransport(selected.transport || fallback.transport),
+        };
+    }
+    if (raw.image || raw.transport || raw.acp_port || raw.entrypoint || raw.workspace_mount_path || raw.state_mount_path) {
+        const fallback = (0, index_js_1.defaultSandboxRuntimeImage)(agentType);
+        return {
+            id: runtimeImageId || fallback.id,
+            agent_type: agentType,
+            image: raw.image || fallback.image,
+            transport: normalizeSandboxTransport(raw.transport || fallback.transport),
+            acp_port: normalizePositiveInteger(raw.acp_port, fallback.acp_port),
+            entrypoint: raw.entrypoint || fallback.entrypoint,
+            workspace_mount_path: raw.workspace_mount_path || fallback.workspace_mount_path,
+            state_mount_path: raw.state_mount_path || fallback.state_mount_path,
+        };
+    }
+    return (0, index_js_1.defaultSandboxRuntimeImage)(agentType);
+}
+function resolveSandboxStateHostPath(config, threadId, runId) {
+    if (!config.stateHostPath) {
+        return '';
+    }
+    const resolved = config.stateHostPath
+        .replaceAll('${LOCAL_AI_THREAD_ID}', sanitizePathSegment(threadId, 'thread'))
+        .replaceAll('${AGENTDOCK_SANDBOX_RUN_ID}', sanitizePathSegment(runId, 'run'));
+    (0, node_fs_1.mkdirSync)(resolved, { recursive: true, mode: 0o700 });
+    return resolved;
+}
+function cleanupRunScopedState(config, statePath) {
+    if (config.stateScope !== 'run' || !statePath || !(0, node_fs_1.existsSync)(statePath)) {
+        return;
+    }
+    (0, node_fs_1.rmSync)(statePath, { recursive: true, force: true });
+}
+function materializeSandboxLaunchConfig(config, env) {
+    const threadId = String(env.LOCAL_AI_THREAD_ID || 'thread');
+    const runId = String(env.AGENTDOCK_SANDBOX_RUN_ID || 'run');
+    const stateHostPath = resolveSandboxStateHostPath(config, threadId, runId);
+    return {
+        ...config,
+        stateHostPath,
+    };
+}
+function defaultSandboxImage(agentType) {
+    return agentType === 'pi' ? exports.DEFAULT_PI_SANDBOX_IMAGE : `agentdock/${agentType}-acp:local`;
+}
+function normalizeServerUrl(value) {
+    const fallback = defaultOpenSandboxServerUrl();
+    return String(value || fallback).trim().replace(/\/+$/, '') || fallback;
+}
+function defaultOpenSandboxServerUrl(env = process.env) {
+    return String(env[exports.DEFAULT_OPENSANDBOX_SERVER_URL_ENV] || exports.DEFAULT_OPENSANDBOX_SERVER_URL)
+        .trim()
+        .replace(/\/+$/, '') || exports.DEFAULT_OPENSANDBOX_SERVER_URL;
+}
+function normalizeStateScope(value) {
+    return value === 'user' || value === 'thread' || value === 'run' ? value : 'project';
+}
+function normalizeSandboxTransport(_value) {
+    return 'http-ndjson';
+}
+function normalizeSandboxLifecycle(value) {
+    return value === 'per_run' ? 'per_run' : 'per_thread';
+}
+function normalizePositiveInteger(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
+}
+function normalizeNonNegativeInteger(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : fallback;
+}
+function normalizeAbsoluteContainerPath(value, fallback) {
+    const normalized = String(value || '').trim();
+    return normalized.startsWith('/') ? normalized : fallback;
+}
+function normalizeEntrypoint(value) {
+    if (Array.isArray(value)) {
+        const entries = value.map((entry) => String(entry || '').trim()).filter(Boolean);
+        if (entries.length > 0) {
+            return entries;
+        }
+    }
+    return ['node', '/opt/agentdock/acp-bridge.mjs'];
+}
+function normalizeRuntimeEnvForSandbox(agentType, env, stateMountPath) {
+    const output = {
+        ...env,
+        AGENTDOCK_SANDBOX_AGENT_TYPE: agentType,
+    };
+    if (agentType === 'pi') {
+        output.PI_CODING_AGENT_DIR = `${stateMountPath}/pi`;
+        output.PI_ACP_PI_COMMAND = '/usr/local/bin/pi';
+    }
+    return output;
+}
+function normalizeRuntimeCommandForSandbox(agentType, command, override) {
+    const runtimeCommand = String(override || '').trim();
+    if (runtimeCommand) {
+        return runtimeCommand;
+    }
+    return agentType === 'pi' ? '/usr/local/bin/pi-acp' : command;
+}
+function normalizeRuntimeArgsForSandbox(agentType, args, override) {
+    if (Array.isArray(override)) {
+        return override.map((entry) => String(entry || '').trim()).filter(Boolean);
+    }
+    return agentType === 'pi' ? [] : args;
+}
+function sandboxProxyScriptPath() {
+    return (0, node_path_1.resolve)(__dirname, 'sandbox-stdio-proxy.js');
+}
+function resolveSandboxProxyCwd(configDir) {
+    const candidates = [
+        String(process.env.AI_WORKSTATION_USER_DATA_DIR || '').trim(),
+        configDir,
+        process.cwd(),
+        '/tmp',
+    ].filter(Boolean);
+    return candidates.find((candidate) => (0, node_fs_1.existsSync)(candidate)) || process.cwd();
+}
+function sandboxProxyLaunchEnv(config) {
+    return {
+        AGENTDOCK_SANDBOX_CONFIG: JSON.stringify(config),
+    };
+}
+function sanitizePathSegment(value, fallback) {
+    return String(value || '')
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '') || fallback;
+}
+function resolveHostPathFromConfigDir(configState, rawPath) {
+    return (0, node_path_1.isAbsolute)(rawPath) ? rawPath : (0, node_path_1.resolve)((0, node_path_1.dirname)(configState.path), rawPath);
+}

package/dist-electron/services/local-ai-core/src/sandbox/sandbox-manager.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxManager = exports.SANDBOX_ENDPOINT_HOST_ENV = void 0;
+exports.resolveOpenSandboxApiKey = resolveOpenSandboxApiKey;
+exports.buildOpenSandboxCreateInput = buildOpenSandboxCreateInput;
+exports.normalizeEndpoint = normalizeEndpoint;
+const node_crypto_1 = require("node:crypto");
+const local_core_errors_js_1 = require("../kernel/local-core-errors.js");
+const sandbox_config_js_1 = require("./sandbox-config.js");
+const opensandbox_client_js_1 = require("./opensandbox-client.js");
+exports.SANDBOX_ENDPOINT_HOST_ENV = 'AGENTDOCK_SANDBOX_ENDPOINT_HOST';
+class SandboxManager {
+    options;
+    activeSandboxId = '';
+    cleaned = false;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        const startedAt = Date.now();
+        const config = (0, sandbox_config_js_1.materializeSandboxLaunchConfig)(this.options.config, this.options.env);
+        const apiKey = resolveOpenSandboxApiKey(config, this.options.env);
+        const client = this.options.client || new opensandbox_client_js_1.OpenSandboxClient({
+            serverUrl: config.serverUrl,
+            apiKey,
+        });
+        await client.health();
+        this.options.log?.(`OpenSandbox health ready in ${Date.now() - startedAt}ms`);
+        const createInput = buildOpenSandboxCreateInput(config, this.options.env);
+        const createStartedAt = Date.now();
+        const sandbox = await client.createSandbox(createInput);
+        this.options.log?.(`OpenSandbox sandbox created in ${Date.now() - createStartedAt}ms id=${sandbox.id}`);
+        this.activeSandboxId = sandbox.id;
+        const runningStartedAt = Date.now();
+        const ready = await this.waitForRunning(client, sandbox.id, config.timeoutSeconds);
+        if (!ready) {
+            throw new local_core_errors_js_1.LocalCoreError('sandbox_start_timeout', `OpenSandbox sandbox ${sandbox.id} did not reach Running state.`, {
+                details: { sandboxId: sandbox.id, timeoutSeconds: config.timeoutSeconds },
+            });
+        }
+        this.options.log?.(`OpenSandbox sandbox running in ${Date.now() - runningStartedAt}ms id=${sandbox.id}`);
+        const endpointStartedAt = Date.now();
+        const endpoint = await client.getEndpoint(sandbox.id, config.acpPort);
+        this.options.log?.(`OpenSandbox endpoint ready in ${Date.now() - endpointStartedAt}ms id=${sandbox.id}`);
+        return {
+            sandboxId: sandbox.id,
+            endpoint: normalizeEndpoint(endpoint.endpoint, this.options.env[exports.SANDBOX_ENDPOINT_HOST_ENV], config.transport),
+            config,
+            stateHostPath: config.stateHostPath || '',
+        };
+    }
+    async cleanup(run) {
+        if (this.cleaned) {
+            return;
+        }
+        this.cleaned = true;
+        const config = run?.config || (0, sandbox_config_js_1.materializeSandboxLaunchConfig)(this.options.config, this.options.env);
+        const sandboxId = run?.sandboxId || this.activeSandboxId;
+        if (sandboxId) {
+            try {
+                const client = this.options.client || new opensandbox_client_js_1.OpenSandboxClient({
+                    serverUrl: config.serverUrl,
+                    apiKey: resolveOpenSandboxApiKey(config, this.options.env),
+                });
+                await client.deleteSandbox(sandboxId);
+            }
+            catch (error) {
+                this.options.log?.(`OpenSandbox cleanup failed for ${sandboxId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        try {
+            (0, sandbox_config_js_1.cleanupRunScopedState)(config, run?.stateHostPath || config.stateHostPath || '');
+        }
+        catch (error) {
+            this.options.log?.(`Sandbox run state cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async waitForRunning(client, sandboxId, timeoutSeconds) {
+        const deadline = Date.now() + Math.min(timeoutSeconds * 1000, 120000);
+        let lastStatus = '';
+        while (Date.now() < deadline) {
+            const sandbox = await client.getSandbox(sandboxId);
+            lastStatus = sandboxStatus(sandbox);
+            if (lastStatus === 'running' || lastStatus === 'ready') {
+                return true;
+            }
+            if (lastStatus === 'failed' || lastStatus === 'error' || lastStatus === 'stopped') {
+                throw new local_core_errors_js_1.LocalCoreError('sandbox_start_failed', `OpenSandbox sandbox ${sandboxId} entered ${lastStatus} state.`, {
+                    details: { sandboxId, status: lastStatus, sandbox },
+                });
+            }
+            await delay(500);
+        }
+        this.options.log?.(`OpenSandbox sandbox ${sandboxId} last status before timeout: ${lastStatus || 'unknown'}`);
+        return false;
+    }
+}
+exports.SandboxManager = SandboxManager;
+function resolveOpenSandboxApiKey(config, env) {
+    const configured = String(env[config.apiKeyEnv] || '').trim();
+    if (configured) {
+        return configured;
+    }
+    return isLocalOpenSandboxServer(config.serverUrl) ? 'agentdock-local' : '';
+}
+function isLocalOpenSandboxServer(serverUrl) {
+    try {
+        const url = new URL(serverUrl);
+        return (url.hostname === '127.0.0.1' || url.hostname === 'localhost' || url.hostname === '::1') && url.port === '8080';
+    }
+    catch {
+        return false;
+    }
+}
+function buildOpenSandboxCreateInput(config, env) {
+    const runId = String(env.AGENTDOCK_SANDBOX_RUN_ID || '').trim();
+    const threadId = String(env.LOCAL_AI_THREAD_ID || '').trim();
+    const workspaceId = String(env.LOCAL_AI_WORKSPACE_ID || config.projectId).trim();
+    const runtimeEnv = {
+        ...config.runtimeEnv,
+        LOCAL_AI_WORKSPACE_ID: workspaceId,
+        LOCAL_AI_THREAD_ID: threadId,
+        LOCAL_AI_WORKSPACE_PATH: config.workspaceMountPath,
+        AGENTDOCK_ACP_PORT: String(config.acpPort),
+        AGENTDOCK_SANDBOX_RUN_ID: runId,
+        AGENTDOCK_SANDBOX_USER_ID: config.userId,
+        AGENTDOCK_SANDBOX_PROJECT_ID: config.projectId,
+        AGENTDOCK_SANDBOX_AGENT_TYPE: config.runtimeEnv.AGENTDOCK_SANDBOX_AGENT_TYPE || '',
+        AGENTDOCK_ACP_COMMAND: config.runtimeCommand,
+        AGENTDOCK_ACP_ARGS: JSON.stringify(config.runtimeArgs || []),
+        AGENTDOCK_ACP_CWD: config.workspaceMountPath,
+        AGENTDOCK_ACP_STATE_DIRS: JSON.stringify([
+            config.stateMountPath,
+            ...Object.entries(config.runtimeEnv)
+                .filter(([key]) => key.endsWith('_DIR'))
+                .map(([, value]) => value),
+        ].filter(Boolean)),
+    };
+    const volumes = [
+        {
+            host: config.workspaceHostPath,
+            container: config.workspaceMountPath,
+            mode: 'rw',
+        },
+    ];
+    if (config.stateHostPath) {
+        volumes.push({
+            host: config.stateHostPath,
+            container: config.stateMountPath,
+            mode: 'rw',
+        });
+    }
+    return {
+        image: config.image,
+        entrypoint: config.entrypoint,
+        env: runtimeEnv,
+        metadata: {
+            userId: metadataLabel(config.userId, 'local'),
+            projectId: metadataLabel(config.projectId, 'project'),
+            workspaceId: metadataLabel(workspaceId, 'workspace'),
+            threadId: metadataLabel(threadId, 'thread'),
+            runId: metadataLabel(runId, 'run'),
+            agentType: metadataLabel(String(config.runtimeEnv.AGENTDOCK_SANDBOX_AGENT_TYPE || ''), 'agent'),
+            stateScope: metadataLabel(config.stateScope, 'project'),
+        },
+        volumes,
+        ports: [config.acpPort],
+        timeoutSeconds: config.timeoutSeconds,
+        cpu: config.cpu,
+        memory: config.memory,
+    };
+}
+function sandboxStatus(sandbox) {
+    const status = sandbox.status;
+    if (status && typeof status === 'object') {
+        const state = status.state;
+        if (state) {
+            return String(state).toLowerCase();
+        }
+    }
+    return String(status || sandbox.state || '').toLowerCase();
+}
+function metadataLabel(value, fallback) {
+    const sanitized = (0, sandbox_config_js_1.sanitizePathSegment)(value, fallback).replaceAll('_', '-');
+    const trimmed = sanitized.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, '') || fallback;
+    if (trimmed.length <= 63) {
+        return trimmed;
+    }
+    const hash = (0, node_crypto_1.createHash)('sha256').update(trimmed).digest('hex').slice(0, 8);
+    return `${trimmed.slice(0, 54).replace(/[^a-zA-Z0-9]+$/g, '')}-${hash}`;
+}
+function normalizeEndpoint(endpoint, endpointHostOverride, _transport = 'http-ndjson') {
+    const trimmed = endpoint.trim();
+    const normalized = (() => {
+        if (trimmed.startsWith('http://') || trimmed.startsWith('https://')) {
+            return trimmed;
+        }
+        return `http://${trimmed}`;
+    })();
+    const override = String(endpointHostOverride || '').trim();
+    if (!override) {
+        return normalized;
+    }
+    try {
+        const url = new URL(normalized);
+        url.hostname = override;
+        return url.toString();
+    }
+    catch {
+        return normalized;
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}