aws-runtime-bridge 1.9.33 → 1.9.41

package/dist/routes/memory.test.js

@@ -1,177 +0,0 @@
-import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { describe, expect, it } from "vitest";
-import { listPermanentMemoriesFromWorkspace, resolvePermanentMemoryStorePath, resolvePermanentMemoryStorePathCandidates, } from "./memory.js";
-describe("runtime permanent memory route helpers", () => {
-    it("resolves permanent memory under the agent workspace", () => {
-        expect(resolvePermanentMemoryStorePath("/workspace/project", "Backend/Engineer:Lead").replace(/\\/g, "/")).toBe("/workspace/project/.agentswork/memory/memory/Backend_Engineer_Lead");
-    });
-    it("uses a stable fallback directory when role name is blank", () => {
-        expect(resolvePermanentMemoryStorePath("/workspace/project", "  ").replace(/\\/g, "/")).toBe("/workspace/project/.agentswork/memory/memory/default-role");
-    });
-    it("resolves the role directory before the default-role fallback", () => {
-        const candidates = resolvePermanentMemoryStorePathCandidates("/workspace/project", "Backend Engineer").map((candidate) => ({
-            ...candidate,
-            path: candidate.path.replace(/\\/g, "/"),
-        }));
-        expect(candidates).toEqual([
-            {
-                path: "/workspace/project/.agentswork/memory/memory/Backend Engineer",
-                isFallback: false,
-            },
-            {
-                path: "/workspace/project/.agentswork/memory/memory/default-role",
-                isFallback: true,
-            },
-        ]);
-    });
-    it("does not duplicate the default-role candidate when role name is blank", () => {
-        const candidates = resolvePermanentMemoryStorePathCandidates("/workspace/project", "  ").map((candidate) => ({
-            ...candidate,
-            path: candidate.path.replace(/\\/g, "/"),
-        }));
-        expect(candidates).toEqual([
-            {
-                path: "/workspace/project/.agentswork/memory/memory/default-role",
-                isFallback: false,
-            },
-        ]);
-    });
-    it("lists only permanent memory records from workspace-local domain files", async () => {
-        const workspacePath = await mkdtemp(path.join(os.tmpdir(), "aws-memory-workspace-"));
-        const storePath = resolvePermanentMemoryStorePath(workspacePath, "Backend Engineer");
-        await mkdir(storePath, { recursive: true });
-        await writeFile(path.join(storePath, "core.json"), JSON.stringify({
-            by_uri: {
-                "core://agent/profile": {
-                    id: "m-1",
-                    uri: "Core://agent/profile/",
-                    content: "profile",
-                    memory_type: "memory",
-                    createdAt: "2026-01-01T00:00:00.000Z",
-                    updatedAt: "2026-01-02T00:00:00.000Z",
-                    version: 2,
-                },
-                "core://task/current": {
-                    id: "t-1",
-                    uri: "core://task/current",
-                    content: "task",
-                    memory_type: "task_list",
-                    createdAt: "2026-01-01T00:00:00.000Z",
-                    updatedAt: "2026-01-03T00:00:00.000Z",
-                    version: 1,
-                },
-            },
-        }), "utf-8");
-        const records = await listPermanentMemoriesFromWorkspace(workspacePath, "Backend Engineer");
-        expect(records).toHaveLength(1);
-        expect(records[0]).toMatchObject({
-            id: "m-1",
-            uri: "core://agent/profile",
-            domain: "core",
-            path: "agent/profile",
-            content: "profile",
-            memory_type: "memory",
-            version: 2,
-        });
-    });
-    it("falls back to default-role records when the requested role directory is empty", async () => {
-        const workspacePath = await mkdtemp(path.join(os.tmpdir(), "aws-memory-workspace-"));
-        const fallbackStorePath = resolvePermanentMemoryStorePath(workspacePath, "");
-        await mkdir(fallbackStorePath, { recursive: true });
-        await writeFile(path.join(fallbackStorePath, "task.json"), JSON.stringify({
-            by_uri: {
-                "task://todo/current": {
-                    id: "m-default-role",
-                    uri: "task://todo/current",
-                    content: "default role memory should still display",
-                    memory_type: "memory",
-                    createdAt: "2026-01-01T00:00:00.000Z",
-                    updatedAt: "2026-01-02T00:00:00.000Z",
-                    version: 1,
-                },
-            },
-        }), "utf-8");
-        const records = await listPermanentMemoriesFromWorkspace(workspacePath, "W网盘开发员-2号");
-        expect(records).toHaveLength(1);
-        expect(records[0]).toMatchObject({
-            id: "m-default-role",
-            uri: "task://todo/current",
-            domain: "task",
-            content: "default role memory should still display",
-        });
-    });
-    it("falls back when the requested role directory has no normalized permanent records", async () => {
-        const workspacePath = await mkdtemp(path.join(os.tmpdir(), "aws-memory-workspace-"));
-        const roleStorePath = resolvePermanentMemoryStorePath(workspacePath, "Backend Engineer");
-        const fallbackStorePath = resolvePermanentMemoryStorePath(workspacePath, "");
-        await mkdir(roleStorePath, { recursive: true });
-        await mkdir(fallbackStorePath, { recursive: true });
-        await writeFile(path.join(roleStorePath, "task.json"), JSON.stringify({
-            by_uri: {
-                "task://todo/server-managed": {
-                    id: "task-list-record",
-                    uri: "task://todo/server-managed",
-                    content: "not a permanent memory",
-                    memory_type: "task_list",
-                    updatedAt: "2026-01-03T00:00:00.000Z",
-                },
-            },
-        }), "utf-8");
-        await writeFile(path.join(fallbackStorePath, "task.json"), JSON.stringify({
-            by_uri: {
-                "task://todo/permanent": {
-                    id: "m-fallback-permanent",
-                    uri: "task://todo/permanent",
-                    content: "fallback permanent memory",
-                    memory_type: "memory",
-                    updatedAt: "2026-01-02T00:00:00.000Z",
-                },
-            },
-        }), "utf-8");
-        const records = await listPermanentMemoriesFromWorkspace(workspacePath, "Backend Engineer");
-        expect(records).toHaveLength(1);
-        expect(records[0]).toMatchObject({
-            id: "m-fallback-permanent",
-            uri: "task://todo/permanent",
-            content: "fallback permanent memory",
-        });
-    });
-    it("keeps role-specific permanent memory isolated when the role directory has records", async () => {
-        const workspacePath = await mkdtemp(path.join(os.tmpdir(), "aws-memory-workspace-"));
-        const roleStorePath = resolvePermanentMemoryStorePath(workspacePath, "Backend Engineer");
-        const fallbackStorePath = resolvePermanentMemoryStorePath(workspacePath, "");
-        await mkdir(roleStorePath, { recursive: true });
-        await mkdir(fallbackStorePath, { recursive: true });
-        await writeFile(path.join(roleStorePath, "core.json"), JSON.stringify({
-            by_uri: {
-                "core://role/specific": {
-                    id: "m-role",
-                    uri: "core://role/specific",
-                    content: "role-specific memory wins",
-                    memory_type: "memory",
-                    updatedAt: "2026-01-03T00:00:00.000Z",
-                },
-            },
-        }), "utf-8");
-        await writeFile(path.join(fallbackStorePath, "core.json"), JSON.stringify({
-            by_uri: {
-                "core://default/old": {
-                    id: "m-default",
-                    uri: "core://default/old",
-                    content: "old default-role memory",
-                    memory_type: "memory",
-                    updatedAt: "2026-01-02T00:00:00.000Z",
-                },
-            },
-        }), "utf-8");
-        const records = await listPermanentMemoriesFromWorkspace(workspacePath, "Backend Engineer");
-        expect(records).toHaveLength(1);
-        expect(records[0]).toMatchObject({
-            id: "m-role",
-            uri: "core://role/specific",
-            content: "role-specific memory wins",
-        });
-    });
-});

package/dist/routes/properties.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Properties 路由单元测试
- */
-export {};
-//# sourceMappingURL=properties.test.d.ts.map

package/dist/routes/properties.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"properties.test.d.ts","sourceRoot":"","sources":["../../src/routes/properties.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/routes/properties.test.js

@@ -1,72 +0,0 @@
-/**
- * Properties 路由单元测试
- */
-import { describe, it, expect } from 'vitest';
-describe('properties route validation', () => {
-    it('requires content for write', () => {
-        const validateWriteRequest = (body) => {
-            if (!body.content || !String(body.content).trim())
-                return { valid: false, error: 'content is required' };
-            return { valid: true };
-        };
-        expect(validateWriteRequest({}).valid).toBe(false);
-        expect(validateWriteRequest({ content: '' }).valid).toBe(false);
-        expect(validateWriteRequest({ content: 'key=value' }).valid).toBe(true);
-    });
-});
-describe('properties file operations', () => {
-    it('resolves relative propertiesPath', () => {
-        const resolvePath = (workspacePath, propertiesPath) => {
-            const defaultPath = '.agentswork/my.properties';
-            const resolved = propertiesPath || defaultPath;
-            if (workspacePath && !resolved.startsWith('/'))
-                return `${workspacePath}/${resolved}`;
-            return resolved;
-        };
-        expect(resolvePath('/project', 'config/app.properties')).toBe('/project/config/app.properties');
-        expect(resolvePath('/project')).toBe('/project/.agentswork/my.properties');
-    });
-    it('parses properties content', () => {
-        const parseProperties = (content) => {
-            const result = {};
-            const lines = content.split('\n');
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!'))
-                    continue;
-                const eqIndex = trimmed.indexOf('=');
-                if (eqIndex > 0) {
-                    result[trimmed.slice(0, eqIndex).trim()] = trimmed.slice(eqIndex + 1).trim();
-                }
-            }
-            return result;
-        };
-        const props = parseProperties(`
-# Comment
-agent.role.name=Backend Developer
-project.workspace.path=/home/project
-    `);
-        expect(props['agent.role.name']).toBe('Backend Developer');
-        expect(props['project.workspace.path']).toBe('/home/project');
-    });
-    it('handles empty content', () => {
-        const parseProperties = (content) => {
-            if (!content.trim())
-                return {};
-            const result = {};
-            const lines = content.split('\n');
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed || trimmed.startsWith('#'))
-                    continue;
-                const eqIndex = trimmed.indexOf('=');
-                if (eqIndex > 0) {
-                    result[trimmed.slice(0, eqIndex).trim()] = trimmed.slice(eqIndex + 1).trim();
-                }
-            }
-            return result;
-        };
-        expect(parseProperties('')).toEqual({});
-        expect(parseProperties('# Only comments')).toEqual({});
-    });
-});

package/dist/routes/pty.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=pty.test.d.ts.map

package/dist/routes/pty.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pty.test.d.ts","sourceRoot":"","sources":["../../src/routes/pty.test.ts"],"names":[],"mappings":""}

package/dist/routes/pty.test.js

@@ -1,82 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-const ptyWrite = vi.fn();
-const ptyKill = vi.fn();
-vi.mock('node-pty', () => ({
-    spawn: vi.fn(() => ({
-        write: ptyWrite,
-        kill: ptyKill,
-        onData: vi.fn(),
-        onExit: vi.fn(),
-    })),
-}));
-const currentDir = dirname(fileURLToPath(import.meta.url));
-afterEach(async () => {
-    const { closeAllPtySessions } = await import('./pty.js');
-    closeAllPtySessions('test-cleanup');
-    ptyWrite.mockClear();
-    ptyKill.mockClear();
-});
-describe('ordinary PTY persistence policy', () => {
-    it('falls back from non-interactive Linux login shells', async () => {
-        const { resolveDefaultShell } = await import('./pty.js');
-        expect(resolveDefaultShell('linux', { SHELL: '/usr/sbin/nologin' }, (candidate) => candidate === '/bin/bash')).toEqual({ shell: '/bin/bash', args: [] });
-        expect(resolveDefaultShell('linux', { SHELL: '/bin/false' }, (candidate) => candidate === '/bin/sh')).toEqual({ shell: '/bin/sh', args: [] });
-    });
-    it('falls back when Linux SHELL points to a missing absolute path', async () => {
-        const { resolveDefaultShell } = await import('./pty.js');
-        expect(resolveDefaultShell('linux', { SHELL: '/missing/shell' }, (candidate) => candidate === '/bin/bash')).toEqual({ shell: '/bin/bash', args: [] });
-    });
-    it('keeps persistent dashboard PTY sessions alive across browser disconnects', () => {
-        const source = readFileSync(resolve(currentDir, './pty.ts'), 'utf-8');
-        expect(source).toContain('persistent: boolean');
-        expect(source).toContain('persistent?: unknown');
-        expect(source).toContain('persistent: input.persistent === true');
-        expect(source).toContain('ownerUserId: String(input.ownerUserId || "").trim() || undefined');
-        expect(source).toContain('tenantId: String(input.tenantId || "").trim() || undefined');
-        expect(source).toContain('projectName: String(input.projectName || "").trim() || undefined');
-        expect(source).toContain('if (!session.persistent) {');
-        expect(source).toContain('resolvePtyExitedTtlMs');
-        expect(source).toContain('closePtySession(session.id, "exited-timeout")');
-        expect(source).toContain('session.sockets.size === 0 && session.status === "running" && !session.persistent');
-    });
-    it('documents optional pre-command injection without exposing template IDs', () => {
-        const source = readFileSync(resolve(currentDir, './pty.ts'), 'utf-8');
-        expect(source).toContain('preCommand?: unknown');
-        expect(source).toContain('preCommand: record.preCommand');
-        expect(source).toContain('injectPtyPreCommand(session, input.preCommand)');
-        expect(source).toContain('command.replace(/\\n/g, "\\r")');
-        expect(source).toContain('session.ptyProcess.write(payload)');
-        expect(source).not.toContain('preCommandTemplateId');
-    });
-    it('writes multiline pre-commands as enter-separated PTY input', async () => {
-        const { createPtySession } = await import('./pty.js');
-        createPtySession({
-            workspacePath: process.cwd(),
-            preCommand: 'echo one\necho two',
-            persistent: true,
-        });
-        expect(ptyWrite).toHaveBeenCalledTimes(1);
-        expect(ptyWrite).toHaveBeenCalledWith('echo one\recho two\r');
-    });
-    it('normalizes a trailing LF to exactly one final PTY enter', async () => {
-        const { createPtySession } = await import('./pty.js');
-        createPtySession({
-            workspacePath: process.cwd(),
-            preCommand: 'echo one\n',
-            persistent: true,
-        });
-        expect(ptyWrite).toHaveBeenCalledTimes(1);
-        expect(ptyWrite).toHaveBeenCalledWith('echo one\r');
-    });
-    it('keeps no-template PTY creation from writing pre-command input', async () => {
-        const { createPtySession } = await import('./pty.js');
-        createPtySession({
-            workspacePath: process.cwd(),
-            persistent: true,
-        });
-        expect(ptyWrite).not.toHaveBeenCalled();
-    });
-});

package/dist/routes/runtime-binding.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=runtime-binding.test.d.ts.map

package/dist/routes/runtime-binding.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtime-binding.test.d.ts","sourceRoot":"","sources":["../../src/routes/runtime-binding.test.ts"],"names":[],"mappings":""}

package/dist/routes/runtime-binding.test.js

@@ -1,32 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-vi.mock("../services/runtime-binding.js", () => ({
-    clearRuntimeBinding: vi.fn(),
-    getRuntimeBindingPublicState: vi.fn(() => ({ paired: true })),
-    getRuntimePairingCode: vi.fn(() => "000-000"),
-    hasRuntimeBinding: vi.fn(() => true),
-    saveRuntimeBinding: vi.fn(),
-    validateRuntimeBindingToken: vi.fn(() => true),
-    validateRuntimePairingCode: vi.fn(() => true),
-}));
-vi.mock("../services/mcp-launch-binding-queue.js", () => ({
-    claimMcpLaunchBinding: vi.fn(),
-    getMcpLaunchQueueSize: vi.fn(() => 0),
-}));
-afterEach(() => {
-    vi.clearAllMocks();
-});
-describe("runtime binding token request", () => {
-    it("rejects bridge-scoped token refresh for MCP nodes", async () => {
-        const { resolveRuntimeTokenRequest } = await import("./runtime-binding.js");
-        const result = resolveRuntimeTokenRequest({
-            userId: "user-1",
-            serverUrl: "ws://localhost:7380/ws/agent",
-            forceRefresh: true,
-            rejectedRuntimeAccessToken: "stale-token",
-        });
-        expect(result).toEqual({
-            success: false,
-            error: "MCP runtime token must be claimed from launch binding; bridge-scoped token refresh is disabled",
-        });
-    });
-});

package/dist/routes/sessions.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Sessions 路由单元测试
- */
-export {};
-//# sourceMappingURL=sessions.test.d.ts.map

package/dist/routes/sessions.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sessions.test.d.ts","sourceRoot":"","sources":["../../src/routes/sessions.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/routes/sessions.test.js

@@ -1,86 +0,0 @@
-/**
- * Sessions 路由单元测试
- */
-import { describe, it, expect } from 'vitest';
-import { resolveActiveSdkSessionSnapshotStatus } from './sessions.js';
-describe('sessions route validation', () => {
-    it('requires agentId for recovery', () => {
-        const validateRecoverRequest = (body) => {
-            if (!body.agentId)
-                return { valid: false, error: 'agentId is required' };
-            return { valid: true };
-        };
-        expect(validateRecoverRequest({}).valid).toBe(false);
-        expect(validateRecoverRequest({ agentId: 'agent-123' }).valid).toBe(true);
-    });
-    it('uses provided workspacePath when available', () => {
-        const resolveWorkspacePath = (provided, persisted) => {
-            return provided || persisted || null;
-        };
-        expect(resolveWorkspacePath('/provided/path', '/persisted/path')).toBe('/provided/path');
-        expect(resolveWorkspacePath(undefined, '/persisted/path')).toBe('/persisted/path');
-        expect(resolveWorkspacePath(undefined, undefined)).toBe(null);
-    });
-    it('resolves command with fallback chain', () => {
-        const resolveCommand = (provided, persisted) => {
-            return provided || persisted || 'claude';
-        };
-        expect(resolveCommand('custom-cmd', 'persisted-cmd')).toBe('custom-cmd');
-        expect(resolveCommand(undefined, 'persisted-cmd')).toBe('persisted-cmd');
-        expect(resolveCommand(undefined, undefined)).toBe('claude');
-    });
-});
-describe('session persistence', () => {
-    it('transitions from running to stopped on exit', () => {
-        const sessions = [
-            { sessionId: 'session-1', status: 'running' },
-            { sessionId: 'session-2', status: 'running' },
-        ];
-        const updated = sessions.map(s => s.sessionId === 'session-1' ? { ...s, status: 'stopped' } : s);
-        expect(updated[0].status).toBe('stopped');
-        expect(updated[1].status).toBe('running');
-    });
-    it('filters out active sessions from persisted list', () => {
-        const active = [{ sessionId: 'session-1' }];
-        const persisted = [{ sessionId: 'session-1' }, { sessionId: 'session-2' }];
-        const activeIds = new Set(active.map(s => s.sessionId));
-        const result = persisted.filter(s => !activeIds.has(s.sessionId));
-        expect(result.length).toBe(1);
-        expect(result[0].sessionId).toBe('session-2');
-    });
-});
-describe('active SDK session snapshots', () => {
-    it('reports the adapter fine-grained status instead of hardcoded running', () => {
-        expect(resolveActiveSdkSessionSnapshotStatus('waiting_input', 'running')).toBe('waiting_input');
-        expect(resolveActiveSdkSessionSnapshotStatus('tool_using', undefined)).toBe('tool_using');
-    });
-    it('keeps idle listener snapshots in waiting_input even if adapter is temporarily tool_using', () => {
-        expect(resolveActiveSdkSessionSnapshotStatus('tool_using', 'waiting_input', 'idle')).toBe('waiting_input');
-    });
-    it('uses current runtime status when adapter status is unavailable', () => {
-        expect(resolveActiveSdkSessionSnapshotStatus(undefined, 'thinking')).toBe('thinking');
-    });
-    it('falls back to running only for legacy sessions without status details', () => {
-        expect(resolveActiveSdkSessionSnapshotStatus(undefined, undefined)).toBe('running');
-    });
-});
-describe('terminal configuration', () => {
-    it('selects correct shell for platform', () => {
-        const getShellConfig = (platform) => {
-            if (platform === 'win32')
-                return { shell: 'powershell.exe', args: ['-NoLogo'] };
-            return { shell: 'bash', args: [] };
-        };
-        expect(getShellConfig('win32').shell).toBe('powershell.exe');
-        expect(getShellConfig('linux').shell).toBe('bash');
-    });
-    it('generates correct terminal environment', () => {
-        const buildTerminalEnv = (agentId, baseEnv) => ({
-            ...baseEnv,
-            AWS_AGENT_ID: agentId,
-        });
-        const env = buildTerminalEnv('agent-123', { PATH: '/usr/bin' });
-        expect(env.AWS_AGENT_ID).toBe('agent-123');
-        expect(env.PATH).toBe('/usr/bin');
-    });
-});

package/dist/routes/skills.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Skills 路由单元测试
- */
-export {};
-//# sourceMappingURL=skills.test.d.ts.map

package/dist/routes/skills.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"skills.test.d.ts","sourceRoot":"","sources":["../../src/routes/skills.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/routes/skills.test.js

@@ -1,50 +0,0 @@
-/**
- * Skills 路由单元测试
- */
-import { describe, it, expect } from 'vitest';
-describe('skills route validation', () => {
-    it('requires agentId for list', () => {
-        const validateListRequest = (body) => {
-            if (!body.agentId)
-                return { valid: false, error: 'agentId is required' };
-            return { valid: true };
-        };
-        expect(validateListRequest({}).valid).toBe(false);
-        expect(validateListRequest({ agentId: 'agent-1' }).valid).toBe(true);
-    });
-    it('requires agentId and skillId for get', () => {
-        const validateGetRequest = (body) => {
-            if (!body.agentId || !body.skillId)
-                return { valid: false, error: 'agentId and skillId are required' };
-            return { valid: true };
-        };
-        expect(validateGetRequest({}).valid).toBe(false);
-        expect(validateGetRequest({ agentId: 'agent-1', skillId: 'skill-1' }).valid).toBe(true);
-    });
-    it('normalizes skill name', () => {
-        const normalizeSkillName = (name) => name ? String(name).trim() : undefined;
-        expect(normalizeSkillName('  test-skill  ')).toBe('test-skill');
-        expect(normalizeSkillName('')).toBe(undefined);
-    });
-    it('normalizes apps', () => {
-        const normalizeApps = (apps) => {
-            if (!apps)
-                return [];
-            if (typeof apps === 'string')
-                return apps.split(',').map(s => s.trim()).filter(Boolean);
-            if (Array.isArray(apps))
-                return apps.filter(s => typeof s === 'string').map(s => String(s).trim()).filter(Boolean);
-            return [];
-        };
-        expect(normalizeApps('claude,opencode')).toEqual(['claude', 'opencode']);
-        expect(normalizeApps(['claude', 'opencode'])).toEqual(['claude', 'opencode']);
-    });
-    it('allows supported per-tool toggle app ids', () => {
-        const isSupportedToggleAppId = (appId) => ['acode', 'claudecode', 'opencode'].includes(appId);
-        expect(isSupportedToggleAppId('acode')).toBe(true);
-        expect(isSupportedToggleAppId('claudecode')).toBe(true);
-        expect(isSupportedToggleAppId('opencode')).toBe(true);
-        expect(isSupportedToggleAppId('codex')).toBe(false);
-        expect(isSupportedToggleAppId('openclaw')).toBe(false);
-    });
-});

package/dist/routes/system-metrics.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=system-metrics.test.d.ts.map

package/dist/routes/system-metrics.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"system-metrics.test.d.ts","sourceRoot":"","sources":["../../src/routes/system-metrics.test.ts"],"names":[],"mappings":""}

package/dist/routes/system-metrics.test.js

@@ -1,16 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
-const currentDir = dirname(fileURLToPath(import.meta.url));
-const srcDir = resolve(currentDir, "..");
-describe("system metrics route wiring", () => {
-    it("mounts the authenticated machine metrics route under /runtime", () => {
-        const routeSource = readFileSync(resolve(currentDir, "./system-metrics.ts"), "utf-8");
-        const indexSource = readFileSync(resolve(srcDir, "./index.ts"), "utf-8");
-        expect(routeSource).toContain('systemMetricsRouter.get("/system-metrics", validateToken');
-        expect(routeSource).toContain("collectSystemMetrics");
-        expect(indexSource).toContain('import { systemMetricsRouter } from "./routes/system-metrics.js";');
-        expect(indexSource).toContain('app.use("/runtime", systemMetricsRouter);');
-    });
-});

package/dist/routes/terminal.stop-options.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=terminal.stop-options.test.d.ts.map

package/dist/routes/terminal.stop-options.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"terminal.stop-options.test.d.ts","sourceRoot":"","sources":["../../src/routes/terminal.stop-options.test.ts"],"names":[],"mappings":""}

package/dist/routes/terminal.stop-options.test.js

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseRuntimeStopOptions, resolveRuntimeContextResetSupport, } from "./terminal.js";
-describe("runtime stop options", () => {
-    it("notifies stopped status for manual stop requests by default", () => {
-        const options = parseRuntimeStopOptions({ sessionId: "session-1" });
-        expect(options).toEqual({
-            statusNotified: true,
-            reason: undefined,
-        });
-    });
-    it("suppresses stopped status for internal context reset requests", () => {
-        const options = parseRuntimeStopOptions({
-            sessionId: "session-1",
-            suppressStatus: true,
-            reason: "context_reset_after_task_submit",
-        });
-        expect(options).toEqual({
-            statusNotified: false,
-            reason: "context_reset_after_task_submit",
-        });
-    });
-});
-describe("runtime context reset support", () => {
-    it("allows only ACode sessions whose adapter exposes resetContext", () => {
-        expect(resolveRuntimeContextResetSupport("acode", true)).toEqual({
-            supported: true,
-        });
-        expect(resolveRuntimeContextResetSupport("claude-code", false)).toEqual({
-            supported: false,
-            statusCode: 400,
-            error: "context reset without restart is only supported by ACode",
-        });
-        expect(resolveRuntimeContextResetSupport("acode", false)).toEqual({
-            supported: false,
-            statusCode: 500,
-            error: "ACode adapter does not expose resetContext",
-        });
-    });
-});

package/dist/routes/terminal.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=terminal.test.d.ts.map

package/dist/routes/terminal.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"terminal.test.d.ts","sourceRoot":"","sources":["../../src/routes/terminal.test.ts"],"names":[],"mappings":""}