@agent-spaces/server 0.1.2 → 0.2.3

package/dist/services/command.js

@@ -0,0 +1,48 @@
+import { v4 as uuid } from 'uuid';
+import * as commandStore from '../storage/command-store.js';
+export function listCommands(workspaceId) {
+    return commandStore.listCommands(workspaceId);
+}
+export function getCommand(workspaceId, commandId) {
+    return commandStore.getCommand(workspaceId, commandId);
+}
+export function createCommand(workspaceId, input) {
+    const now = new Date().toISOString();
+    const cmd = {
+        id: uuid(),
+        name: input.name.trim(),
+        command: input.command,
+        folder: input.folder,
+        cwd: input.cwd,
+        shell: input.shell,
+        env: input.env,
+        autoRestart: input.autoRestart,
+        createdAt: now,
+        updatedAt: now,
+    };
+    const commands = commandStore.listCommands(workspaceId);
+    commands.push(cmd);
+    commandStore.saveCommands(workspaceId, commands);
+    return cmd;
+}
+export function updateCommand(workspaceId, commandId, updates) {
+    const commands = commandStore.listCommands(workspaceId);
+    const idx = commands.findIndex(c => c.id === commandId);
+    if (idx === -1)
+        throw new Error('Command not found');
+    commands[idx] = {
+        ...commands[idx],
+        ...updates,
+        updatedAt: new Date().toISOString(),
+    };
+    commandStore.saveCommands(workspaceId, commands);
+    return commands[idx];
+}
+export function deleteCommand(workspaceId, commandId) {
+    const commands = commandStore.listCommands(workspaceId);
+    const filtered = commands.filter(c => c.id !== commandId);
+    if (filtered.length === commands.length)
+        throw new Error('Command not found');
+    commandStore.saveCommands(workspaceId, filtered);
+}
+//# sourceMappingURL=command.js.map

package/dist/services/issue.js

@@ -4,7 +4,7 @@ import * as channelService from '../services/channel.js';
 import * as taskService from '../services/task.js';
 function ensureChannel(workspaceId, issue) {
     ensureRetryDefaults(workspaceId, issue);
-    const channelMembers = ['user', ...(issue.members || [])];
+    const channelMembers = issue.members || [];
     if (issue.channelId) {
         channelService.updateChannel(workspaceId, issue.channelId, { type: 'issue', issueId: issue.id, members: channelMembers });
         return;
@@ -46,7 +46,7 @@ export function getById(workspaceId, issueId) {
 export function create(workspaceId, input) {
     const now = new Date().toISOString();
     const issueId = uuid();
-    const channelMembers = ['user', ...(input.members || [])];
+    const channelMembers = input.members || [];
     const channel = channelService.createChannel(workspaceId, {
         name: input.title,
         type: 'issue',
@@ -61,8 +61,8 @@ export function create(workspaceId, input) {
         description: input.description,
         status: 'draft',
         tasks: [],
-        assignedAgents: [],
         members: input.members || [],
+        workflowId: input.workflowId,
         retryCount: 0,
         maxRetries: 3,
         createdAt: now,
@@ -85,7 +85,6 @@ export function createForChannel(workspaceId, channelId, input) {
         description: input.description,
         status: 'draft',
         tasks: [],
-        assignedAgents: [],
         members: [],
         retryCount: 0,
         maxRetries: 3,
@@ -171,8 +170,8 @@ export function addAgent(workspaceId, issueId, agentId) {
     const issue = getIssue(workspaceId, issueId);
     if (!issue)
         return null;
-    if (!issue.assignedAgents.includes(agentId)) {
-        issue.assignedAgents.push(agentId);
+    if (!issue.members.includes(agentId)) {
+        issue.members.push(agentId);
         issue.updatedAt = new Date().toISOString();
         updateIssue(issue);
     }

package/dist/services/mcp.js

@@ -0,0 +1,120 @@
+import { existsSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ensureDir, getDataDir } from '../storage/json-store.js';
+import { listTemplates } from './agent.js';
+function getMcpsDir() {
+    return join(getDataDir(), 'mcps');
+}
+function getMcpMetaPath() {
+    return join(getMcpsDir(), '_meta.json');
+}
+function readMeta() {
+    const path = getMcpMetaPath();
+    if (!existsSync(path))
+        return { favorites: [] };
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return { favorites: [] };
+    }
+}
+function writeMeta(meta) {
+    ensureDir(getMcpsDir());
+    writeFileSync(getMcpMetaPath(), JSON.stringify(meta, null, 2), 'utf-8');
+}
+function sanitizeName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'mcp-server';
+}
+export function listMcps() {
+    const agents = listTemplates();
+    const mcpsDir = getMcpsDir();
+    const meta = readMeta();
+    ensureDir(mcpsDir);
+    const files = readdirSync(mcpsDir)
+        .filter((f) => f.endsWith('.json') && !f.startsWith('_'));
+    return files.map((filename) => {
+        const raw = readFileSync(join(mcpsDir, filename), 'utf-8');
+        const parsed = JSON.parse(raw);
+        const name = parsed.name || filename.replace(/\.json$/, '');
+        const boundAgents = agents
+            .filter((a) => {
+            const mcps = a.mcps;
+            if (!mcps || typeof mcps !== 'object')
+                return false;
+            const servers = mcps.mcpServers;
+            return servers && name in servers;
+        })
+            .map((a) => ({
+            id: a.id,
+            name: a.name || 'Agent',
+            avatarUrl: a.avatarUrl,
+        }));
+        return {
+            name,
+            description: parsed.description || '',
+            config: parsed.config || {},
+            favorited: meta.favorites.includes(name),
+            boundAgents,
+        };
+    });
+}
+export function importMcps(jsonText) {
+    const parsed = JSON.parse(jsonText);
+    const servers = {};
+    // Support both { mcpServers: {...} } and flat { name: {...} } formats
+    if (parsed.mcpServers && typeof parsed.mcpServers === 'object') {
+        Object.assign(servers, parsed.mcpServers);
+    }
+    else if (typeof parsed === 'object') {
+        Object.assign(servers, parsed);
+    }
+    const mcpsDir = getMcpsDir();
+    ensureDir(mcpsDir);
+    const results = [];
+    for (const [rawName, config] of Object.entries(servers)) {
+        const name = sanitizeName(rawName);
+        const filePath = join(mcpsDir, `${name}.json`);
+        writeFileSync(filePath, JSON.stringify({ name, config }, null, 2), 'utf-8');
+        results.push({
+            name,
+            description: '',
+            config: config,
+            favorited: false,
+            boundAgents: [],
+        });
+    }
+    return results;
+}
+export function updateMcpConfig(name, config) {
+    const mcpsDir = getMcpsDir();
+    const filePath = join(mcpsDir, `${name}.json`);
+    if (!existsSync(filePath))
+        return false;
+    const raw = readFileSync(filePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    parsed.config = config;
+    writeFileSync(filePath, JSON.stringify(parsed, null, 2), 'utf-8');
+    return true;
+}
+export function deleteMcp(name) {
+    const mcpsDir = getMcpsDir();
+    const filePath = join(mcpsDir, `${name}.json`);
+    if (!existsSync(filePath))
+        return false;
+    unlinkSync(filePath);
+    return true;
+}
+export function toggleFavorite(name) {
+    const meta = readMeta();
+    const idx = meta.favorites.indexOf(name);
+    if (idx >= 0) {
+        meta.favorites.splice(idx, 1);
+    }
+    else {
+        meta.favorites.push(name);
+    }
+    writeMeta(meta);
+    return idx < 0;
+}
+//# sourceMappingURL=mcp.js.map

package/dist/services/notification-hub/bot-commands.js

@@ -6,6 +6,7 @@ import * as issueCommentService from '../issue-comment.js';
 import { gitCommit, gitGenerateCommitMsg, gitPull, gitPush, gitStatus } from '../../adapters/git.js';
 import { botCommandContexts } from './types.js';
 import { truncateLine } from './format.js';
+import { getBotSettings, persistBotMarkdown } from './helpers.js';
 import { startIssueAutomation, getConfiguredBotAgent } from './bot-agent.js';
 import { hasActiveIssueAutomation } from '../../agents/issue-agent-runner.js';
 export function isBuiltInCommand(text) {
@@ -29,6 +30,14 @@ async function executeCommand(input) {
     const context = getBotCommandContext(input.conversationId, input.defaultWorkspaceId);
     const workspaceId = context.workspaceId ?? input.defaultWorkspaceId;
     if (command === '/workspace') {
+        if (args[0]) {
+            const workspace = resolveWorkspace(args[0]);
+            if (!workspace)
+                return `Workspace not found: ${args[0]}`;
+            const nextContext = { workspaceId: workspace.id };
+            botCommandContexts.set(input.conversationId, nextContext);
+            return `Switched workspace:\n${formatWorkspaceDetail(workspace)}`;
+        }
         const workspace = workspaceService.getById(workspaceId);
         return workspace ? formatWorkspaceDetail(workspace, context.issueId) : 'Workspace not found.';
     }
@@ -39,12 +48,11 @@ async function executeCommand(input) {
             : 'No workspaces.';
     }
     if (command === '/workspac') {
-        const nextWorkspaceId = args[0];
-        if (!nextWorkspaceId)
-            return 'Usage: /workspac [id]';
-        const workspace = workspaceService.getById(nextWorkspaceId);
+        if (!args[0])
+            return 'Usage: /workspac [id/name]';
+        const workspace = resolveWorkspace(args[0]);
         if (!workspace)
-            return `Workspace not found: ${nextWorkspaceId}`;
+            return `Workspace not found: ${args[0]}`;
         const nextContext = { workspaceId: workspace.id };
         botCommandContexts.set(input.conversationId, nextContext);
         return `Switched workspace:\n${formatWorkspaceDetail(workspace)}`;
@@ -95,10 +103,10 @@ async function executeCommand(input) {
             const invalid = agentIds.filter((id) => !presetIds.has(id));
             if (invalid.length)
                 return `Agent not found: ${invalid.join(', ')}`;
-            issue.assignedAgents = agentIds;
+            issue.members = agentIds;
             issueService.save(workspaceId, issue);
             botCommandContexts.set(input.conversationId, { ...context, workspaceId, issueId: issue.id });
-            return `Set agents for "${issue.title}": ${agentIds.join(', ')}`;
+            return `Set members for "${issue.title}": ${agentIds.join(', ')}`;
         }
         if (args[0]) {
             const issue = resolveIssue(workspaceId, args[0]);
@@ -163,6 +171,21 @@ async function executeCommand(input) {
         await gitPull(workspaceId);
         return 'Pulled from remote git.';
     }
+    if (command === '/markdown') {
+        const arg = args[0]?.toLowerCase();
+        const current = getBotSettings(workspaceId).markdown;
+        if (arg === 'on' || arg === 'true' || arg === '1') {
+            persistBotMarkdown(workspaceId, true);
+            botCommandContexts.set(input.conversationId, { ...context, workspaceId, markdown: true });
+            return 'Markdown output: ON';
+        }
+        if (arg === 'off' || arg === 'false' || arg === '0') {
+            persistBotMarkdown(workspaceId, false);
+            botCommandContexts.set(input.conversationId, { ...context, workspaceId, markdown: false });
+            return 'Markdown output: OFF';
+        }
+        return `Markdown output: ${current ? 'ON' : 'OFF'}\nUsage: /markdown [on/off]`;
+    }
     if (command === '/help')
         return buildCommandHelp();
     return buildCommandHelp();
@@ -175,7 +198,8 @@ function getBotCommandContext(conversationId, defaultWorkspaceId) {
     const issueId = existing.issueId && issueService.getById(workspaceId, existing.issueId)
         ? existing.issueId
         : undefined;
-    const normalized = { workspaceId, issueId };
+    const markdown = existing.markdown ?? getBotSettings(workspaceId).markdown;
+    const normalized = { workspaceId, issueId, markdown };
     botCommandContexts.set(conversationId, normalized);
     return normalized;
 }
@@ -239,17 +263,26 @@ function formatWorkspaceDetail(workspace, currentIssueId) {
         currentIssueId ? `Current issue: ${currentIssueId}` : undefined,
     ].filter(Boolean).join('\n');
 }
+function resolveWorkspace(idOrName) {
+    const byId = workspaceService.getById(idOrName);
+    if (byId)
+        return byId;
+    const lower = idOrName.toLowerCase();
+    const all = workspaceService.getAll();
+    const match = all.find((w) => w.name.toLowerCase().includes(lower));
+    return match ?? null;
+}
 function resolveIssue(workspaceId, idOrIndex) {
     const byId = issueService.getById(workspaceId, idOrIndex);
     if (byId)
         return byId;
+    const issues = issueService.list(workspaceId)
+        .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
     const index = Number(idOrIndex);
-    if (Number.isInteger(index) && index >= 0) {
-        const issues = issueService.list(workspaceId)
-            .sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    if (Number.isInteger(index) && index >= 0)
         return issues[index] ?? null;
-    }
-    return null;
+    const lower = idOrIndex.toLowerCase();
+    return issues.find((i) => i.title.toLowerCase().includes(lower)) ?? null;
 }
 function formatAgentList(workspaceId) {
     const agents = agentService.listPresets(workspaceId) ?? [];
@@ -279,13 +312,11 @@ function formatIssueDetail(workspaceId, issueId) {
     const tasks = taskService.list(workspaceId, issue.id);
     const comments = issueCommentService.listIssueComments(workspaceId, issue.id);
     const members = issue.members.length ? issue.members.join(', ') : '-';
-    const agents = issue.assignedAgents.length ? issue.assignedAgents.join(', ') : '-';
     return [
         `${issue.title} [${issue.status}]`,
         `ID: ${issue.id}`,
         issue.description ? `Desc: ${issue.description}` : undefined,
         `Members: ${members}`,
-        `Agents: ${agents}`,
         `Tasks: ${tasks.length}`,
         ...tasks.map((task) => `- ${task.title} [${task.status}] ${task.id}`),
         `Comments: ${comments.length}`,
@@ -338,7 +369,7 @@ function buildCommandHelp() {
         'Supported commands:',
         '/workspace',
         '/workspaces',
-        '/workspac [id]',
+        '/workspace [id/name]  (alias: /workspac)',
         '/agents',
         '/issues',
         '/issue',
@@ -350,6 +381,7 @@ function buildCommandHelp() {
         '/task',
         '/comment [msg]',
         '/comments',
+        '/markdown [on/off]',
         '/help',
         '/changes',
         '/commit [desc/auto]',

package/dist/services/notification-hub/helpers.js

@@ -66,6 +66,18 @@ export function persistWeChatGetUpdatesBuf(workspaceId, getUpdatesBuf) {
         },
     });
 }
+export function getBotSettings(workspaceId) {
+    const settings = workspaceService.getById(workspaceId)?.notificationSettings;
+    return { markdown: settings?.botMarkdown !== false };
+}
+export function persistBotMarkdown(workspaceId, markdown) {
+    const workspace = workspaceService.getById(workspaceId);
+    const settings = workspace?.notificationSettings;
+    if (!workspace || !settings)
+        return;
+    settings.botMarkdown = markdown;
+    workspaceService.update(workspaceId, { notificationSettings: { ...settings } });
+}
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/services/pty.js

@@ -1,15 +1,22 @@
 import pty from 'node-pty';
 import { v4 as uuid } from 'uuid';
 const sessions = new Map();
-export function createSession(workspaceId, cwd, onOutput, onExit, shell) {
+export function createSession(workspaceId, cwd, onOutput, onExit, shell, env) {
     const id = uuid();
-    const resolvedShell = shell || process.env.SHELL || '/bin/zsh';
+    const resolvedShell = shell || process.env.SHELL || (process.platform === 'win32' ? 'powershell.exe' : '/bin/zsh') || '/bin/sh';
+    const ptyEnv = {};
+    for (const [k, v] of Object.entries(process.env)) {
+        if (v !== undefined)
+            ptyEnv[k] = v;
+    }
+    if (env)
+        Object.assign(ptyEnv, env);
     const ptyProcess = pty.spawn(resolvedShell, [], {
         name: 'xterm-256color',
         cols: 80,
         rows: 24,
         cwd,
-        env: { ...process.env },
+        env: ptyEnv,
     });
     ptyProcess.onData((data) => onOutput(id, data));
     ptyProcess.onExit(({ exitCode }) => onExit(id, exitCode ?? 0));

package/dist/services/skill.js

@@ -0,0 +1,171 @@
+import { copyFileSync, existsSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { ensureDir, getDataDir } from '../storage/json-store.js';
+import { listTemplates } from './agent.js';
+function getSkillsDir() {
+    return join(getDataDir(), 'skills');
+}
+function getSkillMetaPath() {
+    return join(getSkillsDir(), '_meta.json');
+}
+function readMeta() {
+    const path = getSkillMetaPath();
+    if (!existsSync(path))
+        return { favorites: [] };
+    try {
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return { favorites: [] };
+    }
+}
+function writeMeta(meta) {
+    ensureDir(getSkillsDir());
+    writeFileSync(getSkillMetaPath(), JSON.stringify(meta, null, 2), 'utf-8');
+}
+export function listSkills() {
+    const agents = listTemplates();
+    const skillsDir = getSkillsDir();
+    const meta = readMeta();
+    ensureDir(skillsDir);
+    const skillFiles = readdirSync(skillsDir)
+        .filter((f) => f.endsWith('.md') && !f.startsWith('_'));
+    return skillFiles.map((filename) => {
+        const content = readFileSync(join(skillsDir, filename), 'utf-8');
+        const name = basename(filename, '.md');
+        const fm = parseFrontmatter(content);
+        const boundAgents = agents
+            .filter((a) => (a.skills || []).some((s) => {
+            const skillName = s.replace(/\.md$/i, '');
+            return skillName === name;
+        }))
+            .map((a) => ({
+            id: a.id,
+            name: a.name || 'Agent',
+            avatarUrl: a.avatarUrl,
+        }));
+        return {
+            name,
+            description: fm.description || '',
+            filename,
+            content,
+            favorited: meta.favorites.includes(name),
+            boundAgents,
+        };
+    });
+}
+function parseFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return { name: null, description: null };
+    const lines = match[1].split(/\r?\n/);
+    let name = null;
+    let description = null;
+    for (const line of lines) {
+        if (/^\s*name\s*:/i.test(line)) {
+            name = line.split(':', 2)[1].trim() || null;
+        }
+        else if (/^\s*description\s*:/i.test(line)) {
+            description = line.split(':', 2)[1].trim() || null;
+        }
+    }
+    return { name, description };
+}
+function sanitizeFilename(name) {
+    const safe = name.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'skill';
+    return safe.endsWith('.md') ? safe : `${safe}.md`;
+}
+export function importSkill(filename, content) {
+    const fm = parseFrontmatter(content);
+    const finalName = fm.name
+        ? sanitizeFilename(fm.name)
+        : sanitizeFilename(filename);
+    const skillsDir = getSkillsDir();
+    ensureDir(skillsDir);
+    writeFileSync(join(skillsDir, finalName), content, 'utf-8');
+    return {
+        name: basename(finalName, '.md'),
+        description: fm.description || '',
+        filename: finalName,
+        content,
+        favorited: false,
+        boundAgents: [],
+    };
+}
+export function toggleFavorite(name) {
+    const meta = readMeta();
+    const idx = meta.favorites.indexOf(name);
+    if (idx >= 0) {
+        meta.favorites.splice(idx, 1);
+    }
+    else {
+        meta.favorites.push(name);
+    }
+    writeMeta(meta);
+    return idx < 0;
+}
+export function updateSkillContent(name, content) {
+    const skillsDir = getSkillsDir();
+    const filename = name.endsWith('.md') ? name : `${name}.md`;
+    const filePath = join(skillsDir, filename);
+    if (!existsSync(filePath))
+        return false;
+    writeFileSync(filePath, content, 'utf-8');
+    return true;
+}
+export function deleteSkill(name) {
+    const skillsDir = getSkillsDir();
+    const filename = name.endsWith('.md') ? name : `${name}.md`;
+    const filePath = join(skillsDir, filename);
+    if (!existsSync(filePath))
+        return false;
+    unlinkSync(filePath);
+    return true;
+}
+export function checkSkillSync() {
+    const globalSkillsDir = getSkillsDir();
+    const agents = listTemplates();
+    const result = [];
+    for (const agent of agents) {
+        const skillNames = (agent.skills || []).map((s) => s.replace(/\.md$/i, ''));
+        if (skillNames.length === 0)
+            continue;
+        const agentSkillsDir = join(getDataDir(), 'agent-templates', agent.id, 'skills');
+        for (const skillName of skillNames) {
+            const globalFile = join(globalSkillsDir, `${skillName}.md`);
+            const agentFile = join(agentSkillsDir, `${skillName}.md`);
+            if (!existsSync(globalFile))
+                continue;
+            if (!existsSync(agentFile))
+                continue;
+            const globalStat = statSync(globalFile);
+            const agentStat = statSync(agentFile);
+            if (globalStat.mtimeMs > agentStat.mtimeMs) {
+                result.push({
+                    agentId: agent.id,
+                    agentName: agent.name || agent.id,
+                    skillName,
+                    globalMtime: globalStat.mtime.toISOString(),
+                    agentMtime: agentStat.mtime.toISOString(),
+                });
+            }
+        }
+    }
+    return result;
+}
+export function syncSkills(items) {
+    const globalSkillsDir = getSkillsDir();
+    let synced = 0;
+    for (const item of items) {
+        const globalFile = join(globalSkillsDir, `${item.skillName}.md`);
+        const agentSkillsDir = join(getDataDir(), 'agent-templates', item.agentId, 'skills');
+        const agentFile = join(agentSkillsDir, `${item.skillName}.md`);
+        if (!existsSync(globalFile))
+            continue;
+        ensureDir(agentSkillsDir);
+        copyFileSync(globalFile, agentFile);
+        synced++;
+    }
+    return synced;
+}
+//# sourceMappingURL=skill.js.map

package/dist/services/subscription/aicode.js

@@ -0,0 +1,45 @@
+import { SubscriptionProviderBase } from './base.js';
+export class AiCodeSubscriptionProvider extends SubscriptionProviderBase {
+    provider = 'aicode';
+    async fetchQuota(config) {
+        const url = 'https://www.aicodemirror.com/api/wallet';
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Accept': '*/*',
+                'Referer': 'https://www.aicodemirror.com/dashboard/wallet',
+                ...(config.cookie ? { 'Cookie': config.cookie } : {}),
+                ...(config.headers ?? {}),
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`AiCode API returned ${res.status}: ${res.statusText}`);
+        }
+        const json = await res.json();
+        if (!json.success) {
+            throw new Error('AiCode API returned unsuccessful response');
+        }
+        const balance = Number(json.data.balance) / 1000;
+        const bonus = Number(json.data.bonusBalance) / 1000;
+        return {
+            provider: 'aicode',
+            label: config.label,
+            limits: [
+                {
+                    type: 'balance',
+                    currentValue: Math.round(balance * 100) / 100,
+                    remaining: Math.round(balance * 100) / 100,
+                    percentage: 0,
+                },
+                {
+                    type: 'bonusBalance',
+                    currentValue: Math.round(bonus * 100) / 100,
+                    remaining: Math.round(bonus * 100) / 100,
+                    percentage: 0,
+                },
+            ],
+            fetchedAt: new Date().toISOString(),
+        };
+    }
+}
+//# sourceMappingURL=aicode.js.map

package/dist/services/subscription/base.js

@@ -0,0 +1,3 @@
+export class SubscriptionProviderBase {
+}
+//# sourceMappingURL=base.js.map

package/dist/services/subscription/index.js

@@ -0,0 +1,20 @@
+import { SubscriptionProviderBase } from './base.js';
+import { ZhiPuSubscriptionProvider } from './zhipu.js';
+import { MiniMaxSubscriptionProvider } from './minimax.js';
+import { AiCodeSubscriptionProvider } from './aicode.js';
+const providers = [
+    new ZhiPuSubscriptionProvider(),
+    new MiniMaxSubscriptionProvider(),
+    new AiCodeSubscriptionProvider(),
+];
+function getProvider(provider) {
+    const p = providers.find(p => p.provider === provider);
+    if (!p)
+        throw new Error(`Unknown subscription provider: ${provider}`);
+    return p;
+}
+export async function fetchQuota(config) {
+    return getProvider(config.provider).fetchQuota(config);
+}
+export { SubscriptionProviderBase, ZhiPuSubscriptionProvider };
+//# sourceMappingURL=index.js.map