@agent-spaces/server 0.1.0

package/dist/services/pty.js

@@ -0,0 +1,52 @@
+import pty from 'node-pty';
+import { v4 as uuid } from 'uuid';
+const sessions = new Map();
+export function createSession(workspaceId, cwd, onOutput, onExit, shell) {
+    const id = uuid();
+    const resolvedShell = shell || process.env.SHELL || '/bin/zsh';
+    const ptyProcess = pty.spawn(resolvedShell, [], {
+        name: 'xterm-256color',
+        cols: 80,
+        rows: 24,
+        cwd,
+        env: { ...process.env },
+    });
+    ptyProcess.onData((data) => onOutput(id, data));
+    ptyProcess.onExit(({ exitCode }) => onExit(id, exitCode ?? 0));
+    sessions.set(id, { id, pty: ptyProcess, workspaceId, cwd });
+    return id;
+}
+export function write(sessionId, data) {
+    const session = sessions.get(sessionId);
+    if (!session)
+        return false;
+    session.pty.write(data);
+    return true;
+}
+export function resize(sessionId, cols, rows) {
+    const session = sessions.get(sessionId);
+    if (!session)
+        return false;
+    session.pty.resize(cols, rows);
+    return true;
+}
+export function kill(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session)
+        return false;
+    session.pty.kill();
+    sessions.delete(sessionId);
+    return true;
+}
+export function getSession(sessionId) {
+    return sessions.get(sessionId);
+}
+export function getSessionsByWorkspace(workspaceId) {
+    const result = [];
+    for (const session of sessions.values()) {
+        if (session.workspaceId === workspaceId)
+            result.push(session);
+    }
+    return result;
+}
+//# sourceMappingURL=pty.js.map

package/dist/services/task.js

@@ -0,0 +1,131 @@
+import { v4 as uuid } from 'uuid';
+import { listTasks, getTask, createTask, updateTask, deleteTask } from '../storage/task-store.js';
+export function list(workspaceId, issueId) {
+    const all = listTasks(workspaceId);
+    return issueId ? all.filter((t) => t.issueId === issueId) : all;
+}
+export function getById(workspaceId, taskId) {
+    return getTask(workspaceId, taskId);
+}
+export function create(workspaceId, issueId, data) {
+    const now = new Date().toISOString();
+    const task = {
+        id: uuid(),
+        issueId,
+        workspaceId,
+        title: data.title,
+        description: data.description,
+        status: 'pending',
+        agentConfigId: data.agentConfigId,
+        dependsOnTaskIds: normalizeTaskIds(data.dependsOnTaskIds),
+        sandboxDirs: data.sandboxDirs,
+        retryCount: 0,
+        maxRetries: 3,
+        createdAt: now,
+        updatedAt: now,
+    };
+    createTask(task);
+    return task;
+}
+export function update(workspaceId, taskId, data) {
+    const task = getTask(workspaceId, taskId);
+    if (!task)
+        return null;
+    if (task.status !== 'pending')
+        return null;
+    if (data.title !== undefined)
+        task.title = data.title;
+    if (data.description !== undefined)
+        task.description = data.description;
+    if (Object.hasOwn(data, 'agentConfigId'))
+        task.agentConfigId = data.agentConfigId;
+    if (data.dependsOnTaskIds !== undefined)
+        task.dependsOnTaskIds = normalizeTaskIds(data.dependsOnTaskIds);
+    if (Object.hasOwn(data, 'sandboxDirs'))
+        task.sandboxDirs = data.sandboxDirs;
+    task.updatedAt = new Date().toISOString();
+    updateTask(task);
+    return task;
+}
+export function replaceIssueTasks(workspaceId, issueId, data) {
+    const existing = list(workspaceId, issueId);
+    const removable = existing.filter((task) => task.status !== 'running' && task.status !== 'reviewing');
+    for (const task of removable)
+        deleteTask(workspaceId, task.id);
+    return data.map((task) => create(workspaceId, issueId, {
+        title: task.title,
+        description: task.description,
+        agentConfigId: task.agentConfigId,
+        dependsOnTaskIds: task.dependsOnTaskIds,
+        sandboxDirs: task.sandboxDirs,
+    }));
+}
+export function updateStatus(workspaceId, taskId, status, extra) {
+    const task = getTask(workspaceId, taskId);
+    if (!task)
+        return null;
+    task.status = status;
+    task.updatedAt = new Date().toISOString();
+    if (extra)
+        Object.assign(task, extra);
+    updateTask(task);
+    return task;
+}
+export function markRunningTasksFailed(workspaceId, reason) {
+    const running = list(workspaceId).filter((task) => task.status === 'running' || task.status === 'reviewing' || task.status === 'retrying');
+    return running.map((task) => updateStatus(workspaceId, task.id, 'failed', {
+        result: {
+            success: false,
+            summary: reason,
+            artifacts: [],
+            error: reason,
+        },
+    })).filter((task) => Boolean(task));
+}
+export function resetForRetry(workspaceId, taskId, options = {}) {
+    const task = getTask(workspaceId, taskId);
+    if (!task)
+        return null;
+    const retryCount = options.resetRetryCount
+        ? 0
+        : options.incrementRetry ? (task.retryCount ?? 0) + 1 : (task.retryCount ?? 0);
+    return updateStatus(workspaceId, taskId, 'pending', {
+        retryCount,
+        assignedAgentId: undefined,
+        result: undefined,
+    });
+}
+export function assignAgent(workspaceId, taskId, agentId) {
+    return updateStatus(workspaceId, taskId, 'running', { assignedAgentId: agentId });
+}
+export function complete(workspaceId, taskId, result) {
+    return updateStatus(workspaceId, taskId, result.success ? 'done' : 'failed', { result });
+}
+export function retry(workspaceId, taskId) {
+    const task = getTask(workspaceId, taskId);
+    if (!task)
+        return null;
+    if (task.retryCount >= task.maxRetries) {
+        return updateStatus(workspaceId, taskId, 'failed');
+    }
+    return updateStatus(workspaceId, taskId, 'retrying', {
+        retryCount: task.retryCount + 1,
+    });
+}
+export function cancel(workspaceId, taskId) {
+    return updateStatus(workspaceId, taskId, 'cancelled');
+}
+export function remove(workspaceId, taskId) {
+    const task = getTask(workspaceId, taskId);
+    if (!task)
+        return false;
+    deleteTask(workspaceId, taskId);
+    return true;
+}
+function normalizeTaskIds(ids) {
+    if (!Array.isArray(ids))
+        return undefined;
+    const normalized = ids.map((id) => id.trim()).filter(Boolean);
+    return [...new Set(normalized)];
+}
+//# sourceMappingURL=task.js.map

package/dist/services/tool-detail.js

@@ -0,0 +1,19 @@
+import { join } from 'node:path';
+import { readJsonFile, writeJsonFile, getDataDir } from '../storage/json-store.js';
+function detailFilePath(workspaceId, channelId) {
+    return join(getDataDir(), 'workspaces', workspaceId, 'channels', channelId, 'tool-details.json');
+}
+export function saveToolDetails(workspaceId, channelId, details) {
+    const path = detailFilePath(workspaceId, channelId);
+    const existing = readJsonFile(path) || [];
+    const nextById = new Map(existing.map((detail) => [detail.id, detail]));
+    for (const detail of details) {
+        nextById.set(detail.id, detail);
+    }
+    writeJsonFile(path, Array.from(nextById.values()));
+}
+export function getToolDetail(workspaceId, channelId, messageId, detailId) {
+    const details = readJsonFile(detailFilePath(workspaceId, channelId)) || [];
+    return details.find((detail) => detail.messageId === messageId && detail.id === detailId) ?? null;
+}
+//# sourceMappingURL=tool-detail.js.map

package/dist/services/workspace-prompt.js

@@ -0,0 +1,25 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ensureDir, getDataDir } from '../storage/json-store.js';
+import { getWorkspace } from '../storage/workspace-store.js';
+export const DEFAULT_WORKSPACE_PROMPT = '结果使用中文回复';
+function getWorkspacePromptPath(workspaceId) {
+    return join(getDataDir(), 'workspaces', workspaceId, 'prompt.md');
+}
+export function readWorkspacePrompt(workspaceId) {
+    if (!getWorkspace(workspaceId))
+        return DEFAULT_WORKSPACE_PROMPT;
+    const promptPath = getWorkspacePromptPath(workspaceId);
+    if (!existsSync(promptPath))
+        return DEFAULT_WORKSPACE_PROMPT;
+    return readFileSync(promptPath, 'utf-8');
+}
+export function writeWorkspacePrompt(workspaceId, prompt) {
+    if (!getWorkspace(workspaceId))
+        return null;
+    const promptPath = getWorkspacePromptPath(workspaceId);
+    ensureDir(join(getDataDir(), 'workspaces', workspaceId));
+    writeFileSync(promptPath, prompt, 'utf-8');
+    return prompt;
+}
+//# sourceMappingURL=workspace-prompt.js.map

package/dist/services/workspace.js

@@ -0,0 +1,74 @@
+import { v4 as uuid } from 'uuid';
+import { listWorkspaces, getWorkspace, createWorkspace, updateWorkspace, deleteWorkspace } from '../storage/workspace-store.js';
+import { ensureDir } from '../storage/json-store.js';
+import { join } from 'node:path';
+import { existsSync, writeFileSync } from 'node:fs';
+import { ensureGeneralChannel } from './channel.js';
+const AGENTSPACE_DIRS = ['skills', 'agents', 'tasks', 'cache', 'logs', 'cache/locks'];
+const AGENTSPACE_FILES = {
+    'claude.md': '# Agent Spaces Knowledge Base\n',
+};
+function initAgentspace(agentspaceDir) {
+    ensureDir(agentspaceDir);
+    for (const sub of AGENTSPACE_DIRS) {
+        ensureDir(join(agentspaceDir, sub));
+    }
+    for (const [file, content] of Object.entries(AGENTSPACE_FILES)) {
+        const fullPath = join(agentspaceDir, file);
+        if (!existsSync(fullPath)) {
+            writeFileSync(fullPath, content, 'utf-8');
+        }
+    }
+}
+export function getAll() {
+    return listWorkspaces();
+}
+export function getById(id) {
+    return getWorkspace(id);
+}
+export function create(input) {
+    const id = uuid();
+    const now = new Date().toISOString();
+    const agentspaceDir = join(input.boundDirs[0], '.agentspace');
+    const ws = {
+        id,
+        name: input.name,
+        boundDirs: input.boundDirs,
+        agentspaceDir,
+        createdAt: now,
+        updatedAt: now,
+        activeChannels: [],
+        activeIssues: [],
+        agents: [],
+    };
+    ensureDir(agentspaceDir);
+    initAgentspace(agentspaceDir);
+    createWorkspace(ws);
+    ensureGeneralChannel(id);
+    return ws;
+}
+export function update(id, data) {
+    const ws = getWorkspace(id);
+    if (!ws)
+        return null;
+    const allowed = {};
+    if (Object.hasOwn(data, 'name'))
+        allowed.name = data.name;
+    if (Object.hasOwn(data, 'boundDirs'))
+        allowed.boundDirs = data.boundDirs;
+    if (Object.hasOwn(data, 'autoProcessIssues'))
+        allowed.autoProcessIssues = data.autoProcessIssues;
+    if (Object.hasOwn(data, 'notificationSettings'))
+        allowed.notificationSettings = data.notificationSettings;
+    Object.assign(ws, allowed, { updatedAt: new Date().toISOString() });
+    updateWorkspace(ws);
+    return ws;
+}
+export function remove(id) {
+    const ws = getWorkspace(id);
+    if (!ws)
+        return false;
+    deleteWorkspace(id);
+    return true;
+}
+//# sourceMappingURL=workspace.js.map

package/dist/storage/agent-store.js

@@ -0,0 +1,326 @@
+import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { v4 as uuid } from 'uuid';
+import { getDataDir, ensureDir } from './json-store.js';
+import { listModels } from './llm-store.js';
+let db = null;
+function openDb() {
+    if (db)
+        return db;
+    ensureDir(agentsDir());
+    db = new DatabaseSync(join(agentsDir(), 'agents.sqlite'));
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_sessions (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      agent_config_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      status TEXT NOT NULL,
+      current_task_id TEXT,
+      process_id INTEGER,
+      started_at TEXT NOT NULL,
+      last_activity_at TEXT NOT NULL,
+      error TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_agent_sessions_workspace ON agent_sessions(workspace_id, last_activity_at DESC);
+
+    CREATE TABLE IF NOT EXISTS agent_usage (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL,
+      agent_session_id TEXT NOT NULL,
+      agent_config_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      status TEXT NOT NULL,
+      runtime TEXT,
+      model TEXT,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      cached_input_tokens INTEGER NOT NULL DEFAULT 0,
+      reasoning_tokens INTEGER NOT NULL DEFAULT 0,
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      input_cost_usd REAL NOT NULL DEFAULT 0,
+      output_cost_usd REAL NOT NULL DEFAULT 0,
+      total_cost_usd REAL NOT NULL DEFAULT 0,
+      summary TEXT,
+      error TEXT,
+      started_at TEXT NOT NULL,
+      completed_at TEXT NOT NULL,
+      duration_ms INTEGER,
+      UNIQUE(agent_session_id, completed_at)
+    );
+    CREATE INDEX IF NOT EXISTS idx_agent_usage_completed ON agent_usage(completed_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_agent_usage_workspace_completed ON agent_usage(workspace_id, completed_at DESC);
+  `);
+    return db;
+}
+function agentsDir() {
+    return join(getDataDir(), 'agents');
+}
+export function listAgentSessions(workspaceId) {
+    const database = openDb();
+    const rows = database.prepare(`
+    SELECT * FROM agent_sessions
+    WHERE workspace_id = ?
+    ORDER BY last_activity_at DESC
+  `).all(workspaceId);
+    return rows.map(mapSessionRow);
+}
+export function getAgentSession(workspaceId, sessionId) {
+    const database = openDb();
+    const row = database.prepare(`
+    SELECT * FROM agent_sessions
+    WHERE workspace_id = ? AND id = ?
+  `).get(workspaceId, sessionId);
+    if (row)
+        return mapSessionRow(row);
+    return null;
+}
+export function createAgentSession(session) {
+    const database = openDb();
+    insertSession(database, session);
+}
+export function updateAgentSession(session) {
+    const database = openDb();
+    insertSession(database, session);
+}
+export function deleteAgentSession(workspaceId, sessionId) {
+    const database = openDb();
+    database.prepare('DELETE FROM agent_usage WHERE workspace_id = ? AND agent_session_id = ?').run(workspaceId, sessionId);
+    database.prepare('DELETE FROM agent_sessions WHERE workspace_id = ? AND id = ?').run(workspaceId, sessionId);
+}
+export function recordAgentUsage(input) {
+    const database = openDb();
+    const completedAt = input.session.lastActivityAt || new Date().toISOString();
+    const inputTokens = toCount(input.usage.inputTokens);
+    const outputTokens = toCount(input.usage.outputTokens);
+    const cachedInputTokens = toCount(input.usage.cachedInputTokens);
+    const reasoningTokens = toCount(input.usage.reasoningTokens);
+    const totalTokens = toCount(input.usage.totalTokens) || inputTokens + outputTokens + cachedInputTokens + reasoningTokens;
+    const cost = input.costUsd !== undefined
+        ? splitProvidedCost(input.costUsd, inputTokens + cachedInputTokens, outputTokens + reasoningTokens)
+        : estimateCost(input.model, inputTokens + cachedInputTokens, outputTokens + reasoningTokens);
+    const record = {
+        id: uuid(),
+        workspaceId: input.session.workspaceId,
+        agentSessionId: input.session.id,
+        agentConfigId: input.session.agentConfigId,
+        role: input.session.role,
+        status: input.session.status,
+        runtime: input.runtime,
+        model: input.model,
+        inputTokens,
+        outputTokens,
+        cachedInputTokens,
+        reasoningTokens,
+        totalTokens,
+        inputCostUsd: cost.inputCostUsd,
+        outputCostUsd: cost.outputCostUsd,
+        totalCostUsd: cost.totalCostUsd,
+        summary: input.summary,
+        error: input.session.error,
+        startedAt: input.session.startedAt,
+        completedAt,
+        durationMs: input.durationMs,
+    };
+    database.prepare(`
+    INSERT INTO agent_usage (
+      id, workspace_id, agent_session_id, agent_config_id, role, status, runtime, model,
+      input_tokens, output_tokens, cached_input_tokens, reasoning_tokens, total_tokens,
+      input_cost_usd, output_cost_usd, total_cost_usd, summary, error, started_at, completed_at, duration_ms
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(record.id, record.workspaceId, record.agentSessionId, record.agentConfigId, record.role, record.status, record.runtime ?? null, record.model ?? null, record.inputTokens, record.outputTokens, record.cachedInputTokens, record.reasoningTokens, record.totalTokens, record.inputCostUsd, record.outputCostUsd, record.totalCostUsd, record.summary ?? null, record.error ?? null, record.startedAt, record.completedAt, record.durationMs ?? null);
+    return record;
+}
+export function getAgentUsageDashboard(days = 30) {
+    const database = openDb();
+    const since = new Date(Date.now() - Math.max(days - 1, 0) * 86_400_000);
+    since.setHours(0, 0, 0, 0);
+    const sinceIso = since.toISOString();
+    const records = database.prepare(`
+    SELECT * FROM agent_usage
+    WHERE completed_at >= ?
+    ORDER BY completed_at DESC
+  `).all(sinceIso).map(mapUsageRow);
+    const dailyMap = new Map();
+    for (let index = days - 1; index >= 0; index -= 1) {
+        const date = new Date();
+        date.setDate(date.getDate() - index);
+        const key = date.toISOString().slice(0, 10);
+        dailyMap.set(key, {
+            date: key,
+            label: date.toLocaleDateString('en-US', { weekday: 'short' }),
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            costUsd: 0,
+        });
+    }
+    const modelMap = new Map();
+    let durationTotal = 0;
+    let durationCount = 0;
+    for (const record of records) {
+        const day = dailyMap.get(record.completedAt.slice(0, 10));
+        if (day) {
+            day.inputTokens += record.inputTokens + record.cachedInputTokens;
+            day.outputTokens += record.outputTokens + record.reasoningTokens;
+            day.totalTokens += record.totalTokens;
+            day.costUsd += record.totalCostUsd;
+        }
+        const model = record.model || 'Unknown model';
+        const modelItem = modelMap.get(model) ?? {
+            model,
+            requests: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            costUsd: 0,
+        };
+        modelItem.requests += 1;
+        modelItem.inputTokens += record.inputTokens + record.cachedInputTokens;
+        modelItem.outputTokens += record.outputTokens + record.reasoningTokens;
+        modelItem.totalTokens += record.totalTokens;
+        modelItem.costUsd += record.totalCostUsd;
+        modelMap.set(model, modelItem);
+        if (typeof record.durationMs === 'number' && Number.isFinite(record.durationMs)) {
+            durationTotal += record.durationMs;
+            durationCount += 1;
+        }
+    }
+    const totals = records.reduce((acc, record) => {
+        acc.requests += 1;
+        acc.inputTokens += record.inputTokens + record.cachedInputTokens;
+        acc.outputTokens += record.outputTokens + record.reasoningTokens;
+        acc.totalTokens += record.totalTokens;
+        acc.totalCostUsd += record.totalCostUsd;
+        return acc;
+    }, { requests: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0, totalCostUsd: 0, avgDurationMs: 0 });
+    totals.avgDurationMs = durationCount ? Math.round(durationTotal / durationCount) : 0;
+    return {
+        periodLabel: `${days} days`,
+        totals,
+        daily: Array.from(dailyMap.values()),
+        byModel: Array.from(modelMap.values()).sort((a, b) => b.costUsd - a.costUsd).slice(0, 5),
+        recent: records.slice(0, 6),
+    };
+}
+function insertSession(database, session) {
+    database.prepare(`
+    INSERT INTO agent_sessions (
+      id, workspace_id, agent_config_id, role, status, current_task_id,
+      process_id, started_at, last_activity_at, error
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      workspace_id = excluded.workspace_id,
+      agent_config_id = excluded.agent_config_id,
+      role = excluded.role,
+      status = excluded.status,
+      current_task_id = excluded.current_task_id,
+      process_id = excluded.process_id,
+      started_at = excluded.started_at,
+      last_activity_at = excluded.last_activity_at,
+      error = excluded.error
+  `).run(session.id, session.workspaceId, session.agentConfigId, session.role, session.status, session.currentTaskId ?? null, session.processId ?? null, session.startedAt, session.lastActivityAt, session.error ?? null);
+}
+function mapSessionRow(row) {
+    return {
+        id: String(row.id),
+        workspaceId: String(row.workspace_id),
+        agentConfigId: String(row.agent_config_id),
+        role: row.role,
+        status: row.status,
+        currentTaskId: typeof row.current_task_id === 'string' ? row.current_task_id : undefined,
+        processId: typeof row.process_id === 'number' ? row.process_id : undefined,
+        startedAt: String(row.started_at),
+        lastActivityAt: String(row.last_activity_at),
+        error: typeof row.error === 'string' ? row.error : undefined,
+    };
+}
+function mapUsageRow(row) {
+    return {
+        id: String(row.id),
+        workspaceId: String(row.workspace_id),
+        agentSessionId: String(row.agent_session_id),
+        agentConfigId: String(row.agent_config_id),
+        role: row.role,
+        status: row.status,
+        runtime: typeof row.runtime === 'string' ? row.runtime : undefined,
+        model: typeof row.model === 'string' ? row.model : undefined,
+        inputTokens: toCount(row.input_tokens),
+        outputTokens: toCount(row.output_tokens),
+        cachedInputTokens: toCount(row.cached_input_tokens),
+        reasoningTokens: toCount(row.reasoning_tokens),
+        totalTokens: toCount(row.total_tokens),
+        inputCostUsd: toMoney(row.input_cost_usd),
+        outputCostUsd: toMoney(row.output_cost_usd),
+        totalCostUsd: toMoney(row.total_cost_usd),
+        summary: typeof row.summary === 'string' ? row.summary : undefined,
+        error: typeof row.error === 'string' ? row.error : undefined,
+        startedAt: String(row.started_at),
+        completedAt: String(row.completed_at),
+        durationMs: typeof row.duration_ms === 'number' ? row.duration_ms : undefined,
+    };
+}
+function toCount(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.round(value)) : 0;
+}
+function toMoney(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function estimateCost(model, inputTokens, outputTokens) {
+    const prices = getModelPrices(model);
+    const inputCostUsd = (inputTokens / 1_000_000) * prices.inputPerMillion;
+    const outputCostUsd = (outputTokens / 1_000_000) * prices.outputPerMillion;
+    return {
+        inputCostUsd,
+        outputCostUsd,
+        totalCostUsd: inputCostUsd + outputCostUsd,
+    };
+}
+function splitProvidedCost(costUsd, inputTokens, outputTokens) {
+    const totalCostUsd = toMoney(costUsd);
+    const totalTokens = inputTokens + outputTokens;
+    if (!totalCostUsd || totalTokens === 0) {
+        return { inputCostUsd: 0, outputCostUsd: 0, totalCostUsd };
+    }
+    const inputCostUsd = totalCostUsd * (inputTokens / totalTokens);
+    return {
+        inputCostUsd,
+        outputCostUsd: totalCostUsd - inputCostUsd,
+        totalCostUsd,
+    };
+}
+function getModelPrices(model) {
+    const configured = findConfiguredModelCost(model);
+    if (configured)
+        return configured;
+    const normalized = (model || '').toLowerCase();
+    if (normalized.includes('gpt-4o-mini'))
+        return { inputPerMillion: 0.15, outputPerMillion: 0.6 };
+    if (normalized.includes('gpt-4o'))
+        return { inputPerMillion: 2.5, outputPerMillion: 10 };
+    if (normalized.includes('gpt-5-mini'))
+        return { inputPerMillion: 0.25, outputPerMillion: 2 };
+    if (normalized.includes('gpt-5'))
+        return { inputPerMillion: 1.25, outputPerMillion: 10 };
+    if (normalized.includes('sonnet'))
+        return { inputPerMillion: 3, outputPerMillion: 15 };
+    if (normalized.includes('haiku'))
+        return { inputPerMillion: 0.8, outputPerMillion: 4 };
+    if (normalized.includes('opus'))
+        return { inputPerMillion: 15, outputPerMillion: 75 };
+    if (normalized.includes('gemini'))
+        return { inputPerMillion: 1.25, outputPerMillion: 5 };
+    return { inputPerMillion: 1, outputPerMillion: 3 };
+}
+function findConfiguredModelCost(model) {
+    if (!model)
+        return null;
+    const configured = listModels().find((item) => item.modelId === model || item.name === model);
+    if (!configured?.cost)
+        return null;
+    return {
+        inputPerMillion: toMoney(configured.cost.inputPerMillion),
+        outputPerMillion: toMoney(configured.cost.outputPerMillion),
+    };
+}
+//# sourceMappingURL=agent-store.js.map

package/dist/storage/issue-store.js

@@ -0,0 +1,39 @@
+import { join } from 'node:path';
+import { unlink } from 'node:fs/promises';
+import { getDataDir, ensureDir, readJsonFile, writeJsonFile } from './json-store.js';
+function issuesDir(workspaceId) {
+    return join(getDataDir(), 'workspaces', workspaceId, 'issues');
+}
+function issuesIndex(workspaceId) {
+    return join(issuesDir(workspaceId), 'index.json');
+}
+function issueFile(workspaceId, issueId) {
+    return join(issuesDir(workspaceId), `${issueId}.json`);
+}
+export function listIssues(workspaceId) {
+    return readJsonFile(issuesIndex(workspaceId)) || [];
+}
+export function getIssue(workspaceId, issueId) {
+    return readJsonFile(issueFile(workspaceId, issueId));
+}
+export function createIssue(issue) {
+    ensureDir(issuesDir(issue.workspaceId));
+    writeJsonFile(issueFile(issue.workspaceId, issue.id), issue);
+    const list = listIssues(issue.workspaceId);
+    list.push(issue);
+    writeJsonFile(issuesIndex(issue.workspaceId), list);
+}
+export function updateIssue(issue) {
+    writeJsonFile(issueFile(issue.workspaceId, issue.id), issue);
+    const list = listIssues(issue.workspaceId);
+    const idx = list.findIndex((i) => i.id === issue.id);
+    if (idx >= 0)
+        list[idx] = issue;
+    writeJsonFile(issuesIndex(issue.workspaceId), list);
+}
+export function deleteIssue(workspaceId, issueId) {
+    const list = listIssues(workspaceId).filter((i) => i.id !== issueId);
+    writeJsonFile(issuesIndex(workspaceId), list);
+    unlink(issueFile(workspaceId, issueId)).catch(() => { });
+}
+//# sourceMappingURL=issue-store.js.map