aws-runtime-bridge 1.0.0

package/dist/services/instance-init-service.js

@@ -0,0 +1,190 @@
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { getAgentInitRoot, loadInstanceState, saveInstanceState } from './instance-state.js';
+import { loadCcSwitchSdk, runCcSwitchAdapter, toSdkAppsFromEnabledTools } from './cc-switch-sdk.js';
+import { ensureDir, installSkillPackageToSdk } from '../utils/file-utils.js';
+import { buildMcpConfigContent, normalizeSdkMcpServerSpec, toLegacyMcpStateItem, toLegacySkillStateItem } from '../utils/mcp-utils.js';
+import { ensureEnabledTools, parseBoolean } from '../utils/validation.js';
+import { normalizeMcpPayload } from '../utils/mcp-utils.js';
+import { detectToolStatuses, ensureToolsInstalled } from './tool-installer.js';
+export async function syncLegacyStateFromSdk(agentId, sdk) {
+    const state = await loadInstanceState(agentId);
+    const mcpServers = sdk.getAllMcpServers().map((item) => toLegacyMcpStateItem(item));
+    const skills = sdk.getAllSkills().map((item) => toLegacySkillStateItem(item));
+    state.mcpServers = mcpServers;
+    state.skills = skills;
+    const initRoot = getAgentInitRoot(agentId);
+    const mcpDir = await ensureDir(path.join(initRoot, 'mcp'));
+    const mcpConfigPath = path.join(mcpDir, 'mcp-servers.json');
+    await fs.writeFile(mcpConfigPath, buildMcpConfigContent(mcpServers), 'utf-8');
+    const saved = await saveInstanceState(agentId, state);
+    return {
+        state: saved,
+        configPath: mcpConfigPath,
+        skills,
+        mcpServers,
+    };
+}
+export async function initInstance(agentId, workspacePath, options) {
+    const normalizedWorkspace = path.resolve(workspacePath);
+    const initRoot = getAgentInitRoot(agentId);
+    const logs = [];
+    function pushLog(step, status, message, details) {
+        logs.push({
+            step,
+            status,
+            message,
+            timestamp: new Date().toISOString(),
+            details,
+        });
+    }
+    pushLog('prepare', 'running', '开始初始化实例', {
+        agentId: String(agentId),
+        workspacePath: normalizedWorkspace,
+    });
+    await ensureDir(initRoot);
+    pushLog('prepare', 'success', '初始化目录已就绪', { initRoot });
+    const tools = ensureEnabledTools(options.ccSwitchEnabledTools);
+    pushLog('detect-tools', 'running', '开始检测工具安装状态', { tools });
+    const detectedToolStatus = await detectToolStatuses(tools);
+    pushLog('detect-tools', 'success', '工具安装状态检测完成', {
+        installedTools: Object.values(detectedToolStatus).filter((item) => item.installed).map((item) => item.tool),
+        missingTools: Object.values(detectedToolStatus).filter((item) => !item.installed).map((item) => item.tool),
+    });
+    const initResult = {
+        ok: true,
+        agentId: String(agentId),
+        workspacePath: normalizedWorkspace,
+        initRoot,
+        enabledTools: tools,
+        toolStatus: detectedToolStatus,
+        logs,
+        skill: {
+            enabled: parseBoolean(options.skillEnabled, true),
+            packagePresent: false,
+        },
+        mcp: {
+            enabled: parseBoolean(options.mcpEnabled, true),
+            configPath: null,
+        },
+    };
+    const state = await loadInstanceState(agentId);
+    pushLog('install-tools', 'running', '开始自动安装缺失工具', { tools });
+    const ensuredToolStatus = await ensureToolsInstalled(tools);
+    initResult.toolStatus = ensuredToolStatus;
+    const failedTools = Object.values(ensuredToolStatus).filter((item) => !item.installed);
+    if (failedTools.length > 0) {
+        pushLog('install-tools', 'error', '部分工具自动安装失败', {
+            failedTools: failedTools.map((item) => ({ tool: item.tool, error: item.error })),
+        });
+    }
+    else {
+        pushLog('install-tools', 'success', '工具安装步骤完成', {
+            installedTools: Object.values(ensuredToolStatus).map((item) => ({ tool: item.tool, version: item.version })),
+        });
+    }
+    pushLog('load-sdk', 'running', '开始加载 CC Switch SDK');
+    const sdk = await loadCcSwitchSdk(agentId);
+    const sdkApps = toSdkAppsFromEnabledTools(tools);
+    pushLog('load-sdk', 'success', 'CC Switch SDK 加载完成', { sdkApps });
+    if (initResult.skill.enabled) {
+        pushLog('install-skills', 'running', '开始安装技能包', {
+            count: Array.isArray(options.skillPackages) ? options.skillPackages.length : (options.skillPackage ? 1 : 0),
+        });
+        const skillDir = await ensureDir(path.join(initRoot, 'skills'));
+        const skillCandidates = Array.isArray(options.skillPackages) && options.skillPackages.length > 0
+            ? options.skillPackages
+            : (options.skillPackage ? [options.skillPackage] : []);
+        const installedSkills = [];
+        for (const candidate of skillCandidates) {
+            const installed = await installSkillPackageToSdk(sdk, candidate, skillDir, sdkApps);
+            if (!installed) {
+                continue;
+            }
+            installedSkills.push(toLegacySkillStateItem(installed));
+        }
+        if (installedSkills.length > 0) {
+            initResult.skill.packagePresent = true;
+            initResult.skill.installedCount = installedSkills.length;
+            initResult.skill.installed = installedSkills;
+            pushLog('install-skills', 'success', '技能包安装完成', {
+                installedCount: installedSkills.length,
+                skills: installedSkills.map((item) => item.name),
+            });
+        }
+        else {
+            pushLog('install-skills', 'skipped', '没有可安装的技能包');
+        }
+    }
+    else {
+        pushLog('install-skills', 'skipped', '已跳过技能包安装（skillEnabled=false）');
+    }
+    if (initResult.mcp.enabled) {
+        pushLog('install-mcp', 'running', '开始写入 MCP 配置', {
+            count: Array.isArray(options.mcpServers) ? options.mcpServers.length : 0,
+        });
+        const normalizedMcpServers = (Array.isArray(options.mcpServers) ? options.mcpServers : [])
+            .map((item) => normalizeMcpPayload(item))
+            .filter((item) => item != null);
+        const appliedMcp = [];
+        for (const item of normalizedMcpServers) {
+            const allMcps = sdk.getAllMcpServers();
+            const existing = allMcps.find((server) => String(server?.name || '').trim() === item.name);
+            const mcpInput = {
+                name: item.name,
+                server: normalizeSdkMcpServerSpec(item),
+                apps: sdkApps,
+            };
+            const existingId = String(existing?.id || '').trim();
+            const upserted = existingId
+                ? await sdk.updateMcpServer(existingId, mcpInput)
+                : await sdk.createMcpServer(mcpInput);
+            appliedMcp.push(toLegacyMcpStateItem(upserted));
+        }
+        initResult.mcp.installedCount = appliedMcp.length;
+        pushLog('install-mcp', 'success', 'MCP 配置写入完成', {
+            installedCount: appliedMcp.length,
+            mcpServers: appliedMcp.map((item) => item.name),
+        });
+    }
+    else {
+        pushLog('install-mcp', 'skipped', '已跳过 MCP 配置（mcpEnabled=false）');
+    }
+    pushLog('persist-state', 'running', '开始保存实例状态');
+    state.initialized = true;
+    state.enabledTools = tools;
+    state.toolStatus = ensuredToolStatus;
+    state.skillEnabled = initResult.skill.enabled;
+    state.mcpEnabled = initResult.mcp.enabled;
+    await saveInstanceState(agentId, state);
+    pushLog('persist-state', 'success', '实例状态保存完成');
+    pushLog('sync-state', 'running', '开始同步 CC Switch 状态快照');
+    const synced = await syncLegacyStateFromSdk(agentId, sdk);
+    const savedState = synced.state;
+    initResult.mcp.configPath = synced.configPath;
+    pushLog('sync-state', 'success', 'CC Switch 状态同步完成', {
+        skillCount: savedState.skills.length,
+        mcpCount: savedState.mcpServers.length,
+        configPath: synced.configPath,
+    });
+    pushLog('adapter', 'running', '开始执行适配器回写');
+    const adapterResult = await runCcSwitchAdapter('init-instance', agentId, {
+        enabledTools: savedState.enabledTools,
+        skillEnabled: savedState.skillEnabled,
+        mcpEnabled: savedState.mcpEnabled,
+        skillCount: savedState.skills.length,
+        mcpCount: savedState.mcpServers.length,
+    }, sdk);
+    pushLog('adapter', 'success', '适配器回写完成', {
+        snapshot: adapterResult.snapshot,
+    });
+    pushLog('complete', failedTools.length > 0 ? 'error' : 'success', failedTools.length > 0 ? '实例初始化完成，但存在工具安装失败项' : '实例初始化完成');
+    return {
+        ...initResult,
+        adapterResult,
+        installed: {
+            skills: savedState.skills,
+            mcpServers: savedState.mcpServers,
+        },
+    };
+}

package/dist/services/instance-service.d.ts

@@ -0,0 +1,88 @@
+/**
+ * InstanceService - Agent 实例初始化服务
+ *
+ * 负责 Agent 实例的生命周期管理：
+ * - 实例根目录、workspace 路径管理
+ * - 实例状态持久化
+ * - Skill/MCP 包安装流程
+ *
+ * 注意：此服务属于 Agent 运行时层，不属于 cc-switch-sdk 配置管理层
+ */
+import type { AppId, InstalledSkill, McpServer } from '@cc-switch/sdk';
+import { CcSwitchSdk } from '@cc-switch/sdk';
+export interface SkillPackage {
+    downloadUrl?: string;
+    fileName?: string;
+    sha256?: string;
+    skillName?: string;
+    localPath?: string;
+}
+export interface McpServerInput {
+    id?: string;
+    name: string;
+    transport?: string;
+    command?: string;
+    url?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    enabled?: boolean;
+}
+export interface InstanceOptions {
+    skillEnabled?: boolean;
+    mcpEnabled?: boolean;
+    enabledApps?: AppId[];
+    skillPackage?: SkillPackage;
+    skillPackages?: SkillPackage[];
+    mcpServers?: McpServerInput[];
+}
+export interface InstanceState {
+    initialized: boolean;
+    skills: InstalledSkill[];
+    mcpServers: McpServer[];
+    enabledApps: AppId[];
+    skillEnabled: boolean;
+    mcpEnabled: boolean;
+    updatedAt: string | null;
+}
+export interface InstanceInitResult {
+    ok: boolean;
+    instanceId: string;
+    workspacePath: string;
+    instanceRoot: string;
+    enabledApps: AppId[];
+    skill: {
+        enabled: boolean;
+        packagePresent: boolean;
+        installedCount?: number;
+        installed?: InstalledSkill[];
+    };
+    mcp: {
+        enabled: boolean;
+        installedCount?: number;
+        installed?: McpServer[];
+    };
+}
+export interface InstancePaths {
+    instanceRoot: string;
+    stateFile: string;
+    skillsDir: string;
+    mcpDir: string;
+}
+export declare class InstanceService {
+    private readonly sdk;
+    private readonly instanceRoot;
+    private readonly workspacePath;
+    constructor(sdk: CcSwitchSdk, instanceRoot: string, workspacePath: string);
+    private getPaths;
+    loadState(): Promise<InstanceState>;
+    saveState(state: InstanceState): Promise<InstanceState>;
+    private ensureInstanceRoot;
+    private toAppFlags;
+    initialize(options?: InstanceOptions): Promise<InstanceInitResult>;
+    private installSkillPackage;
+    private upsertMcpServer;
+    getState(): Promise<InstanceState>;
+    updateState(partial: Partial<InstanceState>): Promise<InstanceState>;
+    reset(): Promise<void>;
+}
+//# sourceMappingURL=instance-service.d.ts.map

package/dist/services/instance-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-service.d.ts","sourceRoot":"","sources":["../../src/services/instance-service.ts"],"names":[],"mappings":"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"}

package/dist/services/instance-service.js

@@ -0,0 +1,236 @@
+/**
+ * InstanceService - Agent 实例初始化服务
+ *
+ * 负责 Agent 实例的生命周期管理：
+ * - 实例根目录、workspace 路径管理
+ * - 实例状态持久化
+ * - Skill/MCP 包安装流程
+ *
+ * 注意：此服务属于 Agent 运行时层，不属于 cc-switch-sdk 配置管理层
+ */
+import path from "node:path";
+import { promises as fs } from "node:fs";
+/**
+ * 生成唯一 ID
+ */
+function generateId(prefix = "inst") {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).slice(2, 8);
+    return `${prefix}_${timestamp}_${random}`;
+}
+/**
+ * 检查路径是否存在
+ */
+async function pathExists(target) {
+    try {
+        await fs.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 递归复制目录
+ */
+async function copyDir(source, target) {
+    await fs.mkdir(target, { recursive: true });
+    const entries = await fs.readdir(source, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(source, entry.name);
+        const tgtPath = path.join(target, entry.name);
+        if (entry.isDirectory()) {
+            await copyDir(srcPath, tgtPath);
+        }
+        else {
+            await fs.copyFile(srcPath, tgtPath);
+        }
+    }
+}
+/**
+ * 删除路径（如果存在）
+ */
+async function removeIfExists(target) {
+    try {
+        await fs.rm(target, { recursive: true, force: true });
+    }
+    catch {
+        // ignore
+    }
+}
+export class InstanceService {
+    constructor(sdk, instanceRoot, workspacePath) {
+        this.sdk = sdk;
+        this.instanceRoot = instanceRoot;
+        this.workspacePath = workspacePath;
+    }
+    getPaths() {
+        return {
+            instanceRoot: this.instanceRoot,
+            stateFile: path.join(this.instanceRoot, "instance-state.json"),
+            skillsDir: path.join(this.instanceRoot, "skills"),
+            mcpDir: path.join(this.instanceRoot, "mcp"),
+        };
+    }
+    async loadState() {
+        const paths = this.getPaths();
+        try {
+            const raw = await fs.readFile(paths.stateFile, "utf-8");
+            const parsed = JSON.parse(raw);
+            return parsed;
+        }
+        catch {
+            return {
+                initialized: false,
+                skills: [],
+                mcpServers: [],
+                enabledApps: [],
+                skillEnabled: true,
+                mcpEnabled: true,
+                updatedAt: null,
+            };
+        }
+    }
+    async saveState(state) {
+        const paths = this.getPaths();
+        state.updatedAt = new Date().toISOString();
+        await fs.mkdir(path.dirname(paths.stateFile), { recursive: true });
+        await fs.writeFile(paths.stateFile, JSON.stringify(state, null, 2), "utf-8");
+        return state;
+    }
+    async ensureInstanceRoot() {
+        await fs.mkdir(this.instanceRoot, { recursive: true });
+    }
+    toAppFlags(appIds) {
+        return {
+            claude: appIds.includes("claude"),
+            claudecode: appIds.includes("claudecode"),
+            codex: appIds.includes("codex"),
+            gemini: appIds.includes("gemini"),
+            opencode: appIds.includes("opencode"),
+            openclaw: appIds.includes("openclaw"),
+        };
+    }
+    async initialize(options = {}) {
+        await this.ensureInstanceRoot();
+        const paths = this.getPaths();
+        const enabledApps = options.enabledApps ?? ["claudecode", "opencode"];
+        const appFlags = this.toAppFlags(enabledApps);
+        const result = {
+            ok: true,
+            instanceId: generateId(),
+            workspacePath: this.workspacePath,
+            instanceRoot: this.instanceRoot,
+            enabledApps,
+            skill: {
+                enabled: options.skillEnabled ?? true,
+                packagePresent: false,
+            },
+            mcp: {
+                enabled: options.mcpEnabled ?? true,
+            },
+        };
+        const state = await this.loadState();
+        state.initialized = true;
+        state.enabledApps = enabledApps;
+        state.skillEnabled = result.skill.enabled;
+        state.mcpEnabled = result.mcp.enabled;
+        if (result.skill.enabled) {
+            await fs.mkdir(paths.skillsDir, { recursive: true });
+            const skillCandidates = Array.isArray(options.skillPackages) && options.skillPackages.length > 0
+                ? options.skillPackages
+                : options.skillPackage
+                    ? [options.skillPackage]
+                    : [];
+            const installedSkills = [];
+            for (const candidate of skillCandidates) {
+                const installed = await this.installSkillPackage(candidate, paths.skillsDir, appFlags);
+                if (installed) {
+                    installedSkills.push(installed);
+                }
+            }
+            if (installedSkills.length > 0) {
+                result.skill.packagePresent = true;
+                result.skill.installedCount = installedSkills.length;
+                result.skill.installed = installedSkills;
+                state.skills = installedSkills;
+            }
+        }
+        if (result.mcp.enabled) {
+            const mcpServers = Array.isArray(options.mcpServers)
+                ? options.mcpServers
+                : [];
+            const installedMcps = [];
+            for (const input of mcpServers) {
+                const server = await this.upsertMcpServer(input, appFlags);
+                if (server) {
+                    installedMcps.push(server);
+                }
+            }
+            if (installedMcps.length > 0) {
+                result.mcp.installedCount = installedMcps.length;
+                result.mcp.installed = installedMcps;
+                state.mcpServers = installedMcps;
+            }
+        }
+        await this.saveState(state);
+        return result;
+    }
+    async installSkillPackage(pkg, targetDir, apps) {
+        const sourceDir = pkg.localPath;
+        if (!sourceDir || !(await pathExists(sourceDir))) {
+            return null;
+        }
+        const skillName = pkg.skillName || path.basename(sourceDir).replace(/\.skill$/, "");
+        const skillId = generateId("skill");
+        const targetSkillDir = path.join(targetDir, skillName);
+        await copyDir(sourceDir, targetSkillDir);
+        const installed = await this.sdk.installSkill({
+            sourceDir: targetSkillDir,
+            name: skillName,
+            apps,
+        });
+        return installed;
+    }
+    async upsertMcpServer(input, apps) {
+        const name = String(input.name || "").trim();
+        if (!name) {
+            return null;
+        }
+        const existingMcps = this.sdk.getAllMcpServers();
+        const existing = existingMcps.find((s) => s.name === name);
+        const serverSpec = {
+            type: input.transport || "stdio",
+            command: input.command,
+            url: input.url,
+            args: input.args,
+            env: input.env,
+        };
+        if (existing) {
+            return this.sdk.updateMcpServer(existing.id, {
+                name,
+                server: serverSpec,
+                apps,
+            });
+        }
+        return this.sdk.createMcpServer({
+            name,
+            server: serverSpec,
+            apps,
+        });
+    }
+    async getState() {
+        return this.loadState();
+    }
+    async updateState(partial) {
+        const state = await this.loadState();
+        Object.assign(state, partial);
+        return this.saveState(state);
+    }
+    async reset() {
+        const paths = this.getPaths();
+        await removeIfExists(paths.stateFile);
+        await removeIfExists(paths.skillsDir);
+        await removeIfExists(paths.mcpDir);
+    }
+}

package/dist/services/instance-state.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 实例状态持久化服务
+ *
+ * 管理 Agent 实例的初始化状态持久化
+ */
+import type { InstanceState } from '../types.js';
+/**
+ * 获取实例状态文件路径
+ *
+ * @param agentId - Agent ID
+ * @returns 状态文件路径
+ */
+export declare function getInstanceStateFile(agentId: string): string;
+/**
+ * 加载实例状态
+ *
+ * @param agentId - Agent ID
+ * @returns 实例状态
+ */
+export declare function loadInstanceState(agentId: string): Promise<InstanceState>;
+/**
+ * 保存实例状态
+ *
+ * @param agentId - Agent ID
+ * @param state - 部分实例状态
+ * @returns 完整的实例状态
+ */
+export declare function saveInstanceState(agentId: string, state: Partial<InstanceState>): Promise<InstanceState>;
+/**
+ * 获取 Agent 初始化根目录
+ *
+ * @param agentId - Agent ID
+ * @returns 初始化根目录路径
+ */
+export declare function getAgentInitRoot(agentId: string): string;
+//# sourceMappingURL=instance-state.d.ts.map

package/dist/services/instance-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-state.d.ts","sourceRoot":"","sources":["../../src/services/instance-state.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAiB/E;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,OAAO,CAAC,aAAa,CAAC,GAC5B,OAAO,CAAC,aAAa,CAAC,CAiBxB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAExD"}

package/dist/services/instance-state.js

@@ -0,0 +1,79 @@
+/**
+ * 实例状态持久化服务
+ *
+ * 管理 Agent 实例的初始化状态持久化
+ */
+import path from 'node:path';
+import os from 'node:os';
+import { promises as fs } from 'node:fs';
+import { ensureEnabledTools } from '../utils/validation.js';
+import { parseBoolean } from '../utils/validation.js';
+import { ensureDir } from '../utils/file-utils.js';
+/**
+ * 获取实例状态文件路径
+ *
+ * @param agentId - Agent ID
+ * @returns 状态文件路径
+ */
+export function getInstanceStateFile(agentId) {
+    return path.join(os.tmpdir(), 'agentswork-runtime-init', String(agentId), 'state.json');
+}
+/**
+ * 加载实例状态
+ *
+ * @param agentId - Agent ID
+ * @returns 实例状态
+ */
+export async function loadInstanceState(agentId) {
+    const filePath = getInstanceStateFile(agentId);
+    try {
+        const raw = await fs.readFile(filePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {
+            initialized: false,
+            skills: [],
+            mcpServers: [],
+            enabledTools: ['claude', 'opencode', 'codex'],
+            toolStatus: {},
+            skillEnabled: true,
+            mcpEnabled: true,
+            updatedAt: null,
+        };
+    }
+}
+/**
+ * 保存实例状态
+ *
+ * @param agentId - Agent ID
+ * @param state - 部分实例状态
+ * @returns 完整的实例状态
+ */
+export async function saveInstanceState(agentId, state) {
+    const filePath = getInstanceStateFile(agentId);
+    await ensureDir(path.dirname(filePath));
+    const next = {
+        initialized: Boolean(state?.initialized),
+        skills: Array.isArray(state?.skills) ? state.skills : [],
+        mcpServers: Array.isArray(state?.mcpServers) ? state.mcpServers : [],
+        enabledTools: ensureEnabledTools(state?.enabledTools),
+        toolStatus: state?.toolStatus && typeof state.toolStatus === 'object' && !Array.isArray(state.toolStatus)
+            ? state.toolStatus
+            : {},
+        skillEnabled: parseBoolean(state?.skillEnabled, true),
+        mcpEnabled: parseBoolean(state?.mcpEnabled, true),
+        updatedAt: new Date().toISOString(),
+    };
+    await fs.writeFile(filePath, JSON.stringify(next, null, 2), 'utf-8');
+    return next;
+}
+/**
+ * 获取 Agent 初始化根目录
+ *
+ * @param agentId - Agent ID
+ * @returns 初始化根目录路径
+ */
+export function getAgentInitRoot(agentId) {
+    return path.join(os.tmpdir(), 'agentswork-runtime-init', String(agentId));
+}

package/dist/services/instance-state.test.d.ts

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

package/dist/services/instance-state.test.d.ts.map

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