@thevinci/web 1.0.0

package/server/lib/projects/project-config.test.js

@@ -0,0 +1,175 @@
+import { describe, expect, it } from 'vitest';
+import os from 'os';
+import path from 'path';
+import { mkdtemp, rm, readFile, writeFile } from 'fs/promises';
+import { createProjectConfigRuntime } from './project-config.js';
+
+const createRuntime = async () => {
+  const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'oc-scheduled-project-config-'));
+  const runtime = createProjectConfigRuntime({
+    fsPromises: await import('fs/promises'),
+    path,
+    projectsDirPath: tempRoot,
+    createTaskID: () => 'task-fixed-id',
+  });
+  return {
+    runtime,
+    cleanup: async () => {
+      await rm(tempRoot, { recursive: true, force: true });
+    },
+  };
+};
+
+describe('project-config runtime', () => {
+  it('creates and persists a scheduled task', async () => {
+    const { runtime, cleanup } = await createRuntime();
+    try {
+      const result = await runtime.upsertScheduledTask('project-test', {
+        name: 'Nightly digest',
+        enabled: true,
+        schedule: {
+          kind: 'daily',
+          time: '09:30',
+          timezone: 'UTC',
+        },
+        execution: {
+          prompt: 'Summarize repository changes',
+          providerID: 'openai',
+          modelID: 'gpt-4.1',
+        },
+      });
+
+      expect(result.created).toBe(true);
+      expect(result.task.id).toBe('task-fixed-id');
+      const reloaded = await runtime.listScheduledTasks('project-test');
+      expect(reloaded).toHaveLength(1);
+      expect(reloaded[0].name).toBe('Nightly digest');
+      expect(reloaded[0].schedule.timezone).toBe('UTC');
+      expect(reloaded[0].schedule.times).toEqual(['09:30']);
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it('rejects invalid cron expressions', async () => {
+    const { runtime, cleanup } = await createRuntime();
+    try {
+      await expect(runtime.upsertScheduledTask('project-test', {
+        name: 'Invalid cron task',
+        enabled: true,
+        schedule: {
+          kind: 'cron',
+          cron: 'invalid cron',
+          timezone: 'UTC',
+        },
+        execution: {
+          prompt: 'Run checks',
+          providerID: 'openai',
+          modelID: 'gpt-4.1',
+        },
+      })).rejects.toThrow('schedule.cron is invalid');
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it('preserves unknown project config keys when writing scheduled tasks', async () => {
+    const { runtime, cleanup } = await createRuntime();
+    try {
+      const projectID = 'path_preserve';
+      const filePath = path.join(runtime.resolveProjectConfigPath(projectID));
+      await writeFile(
+        filePath,
+        JSON.stringify({
+          projectNotes: 'hello notes',
+          projectTodos: [{ id: 't1', text: 'buy milk', completed: false, createdAt: 1 }],
+          projectActions: [{ id: 'a1', name: 'Run', command: 'bun run dev' }],
+          projectActionsPrimaryId: 'a1',
+          'setup-worktree': ['bun install'],
+          projectPlanFiles: [{ id: 'p1', path: '/tmp/plans/p1.md', createdAt: 2 }],
+          projectPath: '/tmp/demo',
+        }, null, 2),
+        'utf8',
+      );
+
+      await runtime.upsertScheduledTask(projectID, {
+        name: 'nightly',
+        enabled: true,
+        schedule: { kind: 'daily', time: '09:00', timezone: 'UTC' },
+        execution: { prompt: 'run', providerID: 'openai', modelID: 'gpt-4.1' },
+      });
+
+      const raw = JSON.parse(await readFile(filePath, 'utf8'));
+      expect(raw.projectNotes).toBe('hello notes');
+      expect(raw.projectTodos).toEqual([{ id: 't1', text: 'buy milk', completed: false, createdAt: 1 }]);
+      expect(raw.projectActions).toHaveLength(1);
+      expect(raw.projectActionsPrimaryId).toBe('a1');
+      expect(raw['setup-worktree']).toEqual(['bun install']);
+      expect(raw.projectPlanFiles).toEqual([{ id: 'p1', path: '/tmp/plans/p1.md', createdAt: 2 }]);
+      expect(raw.projectPath).toBe('/tmp/demo');
+      expect(raw.scheduledTasks).toHaveLength(1);
+      expect(raw.version).toBe(1);
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it('preserves scheduled task state timestamps when listing tasks', async () => {
+    const { runtime, cleanup } = await createRuntime();
+    try {
+      const projectID = 'timestamp_preserve';
+      const filePath = path.join(runtime.resolveProjectConfigPath(projectID));
+      await writeFile(
+        filePath,
+        JSON.stringify({
+          scheduledTasks: [{
+            id: 'task-existing',
+            name: 'nightly',
+            enabled: true,
+            schedule: { kind: 'daily', times: ['09:00'], timezone: 'UTC' },
+            execution: { prompt: 'run', providerID: 'openai', modelID: 'gpt-4.1' },
+            state: { createdAt: 10, updatedAt: 20, lastStatus: 'idle' },
+          }],
+        }, null, 2),
+        'utf8',
+      );
+
+      const first = await runtime.listScheduledTasks(projectID);
+      const second = await runtime.listScheduledTasks(projectID);
+
+      expect(first[0].state.createdAt).toBe(10);
+      expect(first[0].state.updatedAt).toBe(20);
+      expect(second[0].state.updatedAt).toBe(20);
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it('accepts one-time schedule with date and time', async () => {
+    const { runtime, cleanup } = await createRuntime();
+    try {
+      const result = await runtime.upsertScheduledTask('project-test', {
+        name: 'One-time review',
+        enabled: true,
+        schedule: {
+          kind: 'once',
+          date: '2026-04-20',
+          time: '13:45',
+          timezone: 'Europe/Kyiv',
+        },
+        execution: {
+          prompt: 'Create a release summary',
+          providerID: 'openai',
+          modelID: 'gpt-4.1',
+        },
+      });
+
+      expect(result.task.schedule.kind).toBe('once');
+      expect(result.task.schedule.date).toBe('2026-04-20');
+      expect(result.task.schedule.time).toBe('13:45');
+      expect(result.task.schedule.timezone).toBe('Europe/Kyiv');
+    } finally {
+      await cleanup();
+    }
+  });
+});

package/server/lib/projects/project-id.js

@@ -0,0 +1,13 @@
+const normalizeProjectPathForId = (value) => {
+  if (typeof value !== 'string') return '';
+  return value.replace(/\\/g, '/').replace(/\/+$/g, '') || value;
+};
+
+export const createProjectIdFromPath = (projectPath) => {
+  const normalized = normalizeProjectPathForId(projectPath).trim();
+  if (!normalized) {
+    return '';
+  }
+
+  return `path_${Buffer.from(normalized, 'utf8').toString('base64url')}`;
+};

package/server/lib/quota/DOCUMENTATION.md

@@ -0,0 +1,58 @@
+# Quota Module Documentation
+
+## Purpose
+This module fetches quota and usage signals for supported providers in the web server runtime.
+
+## Entrypoints and structure
+- `packages/web/server/lib/quota/index.js`: public entrypoint imported by `packages/web/server/index.js`.
+- `packages/web/server/lib/quota/routes.js`: Express route registration for quota endpoints.
+- `packages/web/server/lib/quota/providers/index.js`: provider registry, configured-provider list, and provider dispatcher.
+- `packages/web/server/lib/quota/providers/interface.js`: JSDoc provider contract used as implementation reference.
+- `packages/web/server/lib/quota/providers/google/`: Google-specific auth, API, and transform modules.
+- `packages/web/server/lib/quota/utils/`: shared auth, transform, and formatting helpers.
+
+## Supported provider IDs (dispatcher)
+
+These provider IDs are currently dispatchable via `fetchQuotaForProvider(providerId)` in `packages/web/server/lib/quota/providers/index.js`.
+
+| Provider ID | Display name | Module | Auth aliases/keys |
+| --- | --- | --- | --- |
+| `claude` | Claude | `providers/claude.js` | `anthropic`, `claude` |
+| `codex` | Codex | `providers/codex.js` | `openai`, `codex`, `chatgpt` |
+| `google` | Google | `providers/google/index.js` | `google`, `google.oauth`, Antigravity accounts file |
+| `github-copilot` | GitHub Copilot | `providers/copilot.js` | `github-copilot`, `copilot` |
+| `github-copilot-addon` | GitHub Copilot Add-on | `providers/copilot.js` | `github-copilot`, `copilot` |
+| `kimi-for-coding` | Kimi for Coding | `providers/kimi.js` | `kimi-for-coding`, `kimi` |
+| `nano-gpt` | NanoGPT | `providers/nanogpt.js` | `nano-gpt`, `nanogpt`, `nano_gpt` |
+| `openrouter` | OpenRouter | `providers/openrouter.js` | `openrouter` |
+| `zai-coding-plan` | z.ai | `providers/zai.js` | `zai-coding-plan`, `zai`, `z.ai` |
+| `zhipuai-coding-plan` | Zhipu AI Coding Plan | `providers/zhipuai-coding-plan.js` | `zhipuai-coding-plan` |
+| `minimax-coding-plan` | MiniMax Coding Plan (minimax.io) | `providers/minimax-coding-plan.js` | `minimax-coding-plan` |
+| `minimax-cn-coding-plan` | MiniMax Coding Plan (minimaxi.com) | `providers/minimax-cn-coding-plan.js` | `minimax-cn-coding-plan` |
+| `ollama-cloud` | Ollama Cloud | `providers/ollama-cloud.js` | Cookie file at `~/.config/ollama-quota/cookie` (raw session cookie string) |
+| `zhipuai-coding-plan` | ZhipuAI | `providers/zhipuai.js` | `zhipuai-coding-plan`, `zhipuai`, `zhipu` |
+
+## Internal-only provider module
+- `providers/openai.js` exists for logic parity/reuse but is intentionally not registered for dispatcher ID routing.
+
+## Response contract
+All providers should return results via shared helpers to preserve API shape:
+- Required fields: `providerId`, `providerName`, `ok`, `configured`, `usage`, `fetchedAt`
+- Optional field: `error`
+- Unsupported provider requests should return `ok: false`, `configured: false`, `error: Unsupported provider`
+
+## Add a new provider (quick steps)
+1. Choose module shape based on complexity:
+   - Simple providers: create `packages/web/server/lib/quota/providers/<provider>.js`.
+   - Complex providers (multi-source auth, multiple API calls, non-trivial transforms): create `packages/web/server/lib/quota/providers/<provider>/` with split modules like Google (`index.js`, `auth.js`, `api.js`, `transforms.js`).
+2. Export `providerId`, `providerName`, `aliases`, `isConfigured`, and `fetchQuota`.
+3. Use shared helpers from `packages/web/server/lib/quota/utils/index.js` (`buildResult`, `toUsageWindow`, auth/conversion helpers) to keep payload shape consistent.
+4. Register the provider in `packages/web/server/lib/quota/providers/index.js`.
+5. If needed for direct use, export a named fetcher from `packages/web/server/lib/quota/providers/index.js` and `packages/web/server/lib/quota/index.js`.
+6. Update this file with the new provider ID, module path, and alias/auth details.
+7. Validate with `bun run type-check`, `bun run lint`, and `bun run build`.
+
+## Notes for contributors
+- Keep provider IDs stable; clients use them directly.
+- Avoid adding alias-based dispatch in `fetchQuotaForProvider`; dispatch currently expects exact provider IDs.
+- Keep Google behavior changes isolated and review `providers/google/*` together.

package/server/lib/quota/index.js

@@ -0,0 +1,25 @@
+/**
+ * Quota module
+ *
+ * Provides quota usage tracking for various AI provider services.
+ * @module quota
+ */
+
+export {
+  listConfiguredQuotaProviders,
+  fetchQuotaForProvider,
+  fetchClaudeQuota,
+  fetchOpenaiQuota,
+  fetchGoogleQuota,
+  fetchCodexQuota,
+  fetchCopilotQuota,
+  fetchCopilotAddonQuota,
+  fetchKimiQuota,
+  fetchOpenRouterQuota,
+  fetchZaiQuota,
+  fetchNanoGptQuota,
+  fetchMinimaxCodingPlanQuota,
+  fetchMinimaxCnCodingPlanQuota,
+  fetchOllamaCloudQuota,
+  fetchZhipuaiQuota
+} from './providers/index.js';

package/server/lib/quota/providers/claude.js

@@ -0,0 +1,107 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  toTimestamp
+} from '../utils/index.js';
+
+export const providerId = 'claude';
+export const providerName = 'Claude';
+export const aliases = ['anthropic', 'claude'];
+
+export const isConfigured = () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  return Boolean(entry?.access || entry?.token);
+};
+
+export const fetchQuota = async () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  const accessToken = entry?.access ?? entry?.token;
+
+  if (!accessToken) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: false,
+      error: 'Not configured'
+    });
+  }
+
+  try {
+    const response = await fetch('https://api.anthropic.com/api/oauth/usage', {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        'anthropic-beta': 'oauth-2025-04-20'
+      }
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: `API error: ${response.status}`
+      });
+    }
+
+    const payload = await response.json();
+    const windows = {};
+    const fiveHour = payload?.five_hour ?? null;
+    const sevenDay = payload?.seven_day ?? null;
+    const sevenDaySonnet = payload?.seven_day_sonnet ?? null;
+    const sevenDayOpus = payload?.seven_day_opus ?? null;
+
+    if (fiveHour) {
+      windows['5h'] = toUsageWindow({
+        usedPercent: toNumber(fiveHour.utilization),
+        windowSeconds: null,
+        resetAt: toTimestamp(fiveHour.resets_at)
+      });
+    }
+    if (sevenDay) {
+      windows['7d'] = toUsageWindow({
+        usedPercent: toNumber(sevenDay.utilization),
+        windowSeconds: null,
+        resetAt: toTimestamp(sevenDay.resets_at)
+      });
+    }
+    if (sevenDaySonnet) {
+      windows['7d-sonnet'] = toUsageWindow({
+        usedPercent: toNumber(sevenDaySonnet.utilization),
+        windowSeconds: null,
+        resetAt: toTimestamp(sevenDaySonnet.resets_at)
+      });
+    }
+    if (sevenDayOpus) {
+      windows['7d-opus'] = toUsageWindow({
+        usedPercent: toNumber(sevenDayOpus.utilization),
+        windowSeconds: null,
+        resetAt: toTimestamp(sevenDayOpus.resets_at)
+      });
+    }
+
+    return buildResult({
+      providerId,
+      providerName,
+      ok: true,
+      configured: true,
+      usage: { windows }
+    });
+  } catch (error) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed'
+    });
+  }
+};

package/server/lib/quota/providers/codex.js

@@ -0,0 +1,113 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  toTimestamp,
+  formatMoney
+} from '../utils/index.js';
+
+export const providerId = 'codex';
+export const providerName = 'Codex';
+export const aliases = ['openai', 'codex', 'chatgpt'];
+
+export const isConfigured = () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  return Boolean(entry?.access || entry?.token);
+};
+
+export const fetchQuota = async () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  const accessToken = entry?.access ?? entry?.token;
+  const accountId = entry?.accountId;
+
+  if (!accessToken) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: false,
+      error: 'Not configured'
+    });
+  }
+
+  try {
+    const headers = {
+      Authorization: `Bearer ${accessToken}`,
+      'Content-Type': 'application/json',
+      ...(accountId ? { 'ChatGPT-Account-Id': accountId } : {})
+    };
+    const response = await fetch('https://chatgpt.com/backend-api/wham/usage', {
+      method: 'GET',
+      headers
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: response.status === 401
+          ? 'Session expired \u2014 please re-authenticate with OpenAI'
+          : `API error: ${response.status}`
+      });
+    }
+
+    const payload = await response.json();
+    const primary = payload?.rate_limit?.primary_window ?? null;
+    const secondary = payload?.rate_limit?.secondary_window ?? null;
+    const credits = payload?.credits ?? null;
+
+    const windows = {};
+    if (primary) {
+      windows['5h'] = toUsageWindow({
+        usedPercent: toNumber(primary.used_percent),
+        windowSeconds: toNumber(primary.limit_window_seconds),
+        resetAt: toTimestamp(primary.reset_at)
+      });
+    }
+    if (secondary) {
+      windows['weekly'] = toUsageWindow({
+        usedPercent: toNumber(secondary.used_percent),
+        windowSeconds: toNumber(secondary.limit_window_seconds),
+        resetAt: toTimestamp(secondary.reset_at)
+      });
+    }
+    if (credits) {
+      const balance = toNumber(credits.balance);
+      const unlimited = Boolean(credits.unlimited);
+      const label = unlimited
+        ? 'Unlimited'
+        : balance !== null
+          ? `$${formatMoney(balance)} remaining`
+          : null;
+      windows.credits = toUsageWindow({
+        usedPercent: null,
+        windowSeconds: null,
+        resetAt: null,
+        valueLabel: label
+      });
+    }
+
+    return buildResult({
+      providerId,
+      providerName,
+      ok: true,
+      configured: true,
+      usage: { windows }
+    });
+  } catch (error) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed'
+    });
+  }
+};

package/server/lib/quota/providers/copilot.js

@@ -0,0 +1,165 @@
+import { readAuthFile } from '../../opencode/auth.js';
+import {
+  getAuthEntry,
+  normalizeAuthEntry,
+  buildResult,
+  toUsageWindow,
+  toNumber,
+  toTimestamp
+} from '../utils/index.js';
+
+const buildCopilotWindows = (payload) => {
+  const quota = payload?.quota_snapshots ?? {};
+  const resetAt = toTimestamp(payload?.quota_reset_date);
+  const windows = {};
+
+  const addWindow = (label, snapshot) => {
+    if (!snapshot) return;
+    const entitlement = toNumber(snapshot.entitlement);
+    const remaining = toNumber(snapshot.remaining);
+    const usedPercent = entitlement && remaining !== null
+      ? Math.max(0, 100 - (remaining / entitlement) * 100)
+      : null;
+    const valueLabel = entitlement !== null && remaining !== null
+      ? `${remaining.toFixed(0)} / ${entitlement.toFixed(0)} left`
+      : null;
+    windows[label] = toUsageWindow({
+      usedPercent,
+      windowSeconds: null,
+      resetAt,
+      valueLabel
+    });
+  };
+
+  addWindow('chat', quota.chat);
+  addWindow('completions', quota.completions);
+  addWindow('premium', quota.premium_interactions);
+
+  return windows;
+};
+
+export const providerId = 'github-copilot';
+export const providerName = 'GitHub Copilot';
+export const aliases = ['github-copilot', 'copilot'];
+
+export const isConfigured = () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  return Boolean(entry?.access || entry?.token);
+};
+
+export const fetchQuota = async () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  const accessToken = entry?.access ?? entry?.token;
+
+  if (!accessToken) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: false,
+      error: 'Not configured'
+    });
+  }
+
+  try {
+    const response = await fetch('https://api.github.com/copilot_internal/user', {
+      method: 'GET',
+      headers: {
+        Authorization: `token ${accessToken}`,
+        Accept: 'application/json',
+        'Editor-Version': 'vscode/1.96.2',
+        'X-Github-Api-Version': '2025-04-01'
+      }
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId,
+        providerName,
+        ok: false,
+        configured: true,
+        error: `API error: ${response.status}`
+      });
+    }
+
+    const payload = await response.json();
+    return buildResult({
+      providerId,
+      providerName,
+      ok: true,
+      configured: true,
+      usage: { windows: buildCopilotWindows(payload) }
+    });
+  } catch (error) {
+    return buildResult({
+      providerId,
+      providerName,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed'
+    });
+  }
+};
+
+export const providerIdAddon = 'github-copilot-addon';
+export const providerNameAddon = 'GitHub Copilot Add-on';
+
+export const fetchQuotaAddon = async () => {
+  const auth = readAuthFile();
+  const entry = normalizeAuthEntry(getAuthEntry(auth, aliases));
+  const accessToken = entry?.access ?? entry?.token;
+
+  if (!accessToken) {
+    return buildResult({
+      providerId: providerIdAddon,
+      providerName: providerNameAddon,
+      ok: false,
+      configured: false,
+      error: 'Not configured'
+    });
+  }
+
+  try {
+    const response = await fetch('https://api.github.com/copilot_internal/user', {
+      method: 'GET',
+      headers: {
+        Authorization: `token ${accessToken}`,
+        Accept: 'application/json',
+        'Editor-Version': 'vscode/1.96.2',
+        'X-Github-Api-Version': '2025-04-01'
+      }
+    });
+
+    if (!response.ok) {
+      return buildResult({
+        providerId: providerIdAddon,
+        providerName: providerNameAddon,
+        ok: false,
+        configured: true,
+        error: `API error: ${response.status}`
+      });
+    }
+
+    const payload = await response.json();
+    const windows = buildCopilotWindows(payload);
+    const premium = windows.premium ? { premium: windows.premium } : windows;
+
+    return buildResult({
+      providerId: providerIdAddon,
+      providerName: providerNameAddon,
+      ok: true,
+      configured: true,
+      usage: { windows: premium }
+    });
+  } catch (error) {
+    return buildResult({
+      providerId: providerIdAddon,
+      providerName: providerNameAddon,
+      ok: false,
+      configured: true,
+      error: error instanceof Error ? error.message : 'Request failed'
+    });
+  }
+};