@axhub/genie 0.1.3 → 0.1.4

package/dist/icons/opencode-white.svg

@@ -1,4 +0,0 @@
-<svg width="256" height="256" viewBox="0 0 256 256" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="OpenCode">
-  <rect width="256" height="256" rx="56" fill="#f8fafc"/>
-  <path d="M74 128c0-30.9 23.7-56 53-56h42v28h-39c-14.4 0-26 12.5-26 28s11.6 28 26 28h39v28h-42c-29.3 0-53-25.1-53-56z" fill="#111827"/>
-</svg>

package/dist/icons/opencode.svg

@@ -1,10 +0,0 @@
-<svg width="256" height="256" viewBox="0 0 256 256" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="OpenCode">
-  <defs>
-    <linearGradient id="g" x1="0" y1="0" x2="1" y2="1">
-      <stop offset="0%" stop-color="#10b981"/>
-      <stop offset="100%" stop-color="#059669"/>
-    </linearGradient>
-  </defs>
-  <rect width="256" height="256" rx="56" fill="url(#g)"/>
-  <path d="M74 128c0-30.9 23.7-56 53-56h42v28h-39c-14.4 0-26 12.5-26 28s11.6 28 26 28h39v28h-42c-29.3 0-53-25.1-53-56z" fill="#ffffff"/>
-</svg>

package/server/opencode-manager.js

@@ -1,605 +0,0 @@
-import { spawn } from 'child_process';
-import { promises as fs } from 'fs';
-import os from 'os';
-import path from 'path';
-import fetch from 'node-fetch';
-import { createOpencodeClient } from '@opencode-ai/sdk/client';
-
-const DEFAULT_HOST = process.env.OPENCODE_SERVER_HOST || '127.0.0.1';
-const DEFAULT_PORT = Number(process.env.OPENCODE_SERVER_PORT || 4096);
-const EXTERNAL_BASE_URL = (process.env.OPENCODE_BASE_URL || '').trim();
-const DEFAULT_MODEL = process.env.OPENCODE_DEFAULT_MODEL || 'opencode/gpt-5-nano';
-
-let managedServerProcess = null;
-let serverStartPromise = null;
-let resolvedBaseUrl = EXTERNAL_BASE_URL || `http://${DEFAULT_HOST}:${DEFAULT_PORT}`;
-
-function buildAuthHeader() {
-  const password = process.env.OPENCODE_SERVER_PASSWORD;
-  if (!password) return null;
-
-  const username = process.env.OPENCODE_SERVER_USERNAME || 'opencode';
-  const token = Buffer.from(`${username}:${password}`).toString('base64');
-  return `Basic ${token}`;
-}
-
-function buildClientOptions(baseUrl, directory = null) {
-  const authHeader = buildAuthHeader();
-  const options = { baseUrl };
-
-  if (directory) {
-    options.directory = directory;
-  }
-
-  if (authHeader) {
-    options.headers = {
-      Authorization: authHeader
-    };
-  }
-
-  return options;
-}
-
-async function checkServerHealth(baseUrl, timeoutMs = 2000) {
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-
-  try {
-    const authHeader = buildAuthHeader();
-    const response = await fetch(`${baseUrl}/global/health`, {
-      signal: controller.signal,
-      headers: authHeader ? { Authorization: authHeader } : undefined
-    });
-
-    if (!response.ok) {
-      return false;
-    }
-
-    const payload = await response.json();
-    return payload?.healthy === true;
-  } catch {
-    return false;
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-function parseServerUrlFromOutput(output) {
-  if (!output) return null;
-  const match = output.match(/opencode server listening on\s+(https?:\/\/[^\s]+)/i);
-  return match ? match[1] : null;
-}
-
-async function startManagedServer() {
-  if (managedServerProcess && !managedServerProcess.killed) {
-    return resolvedBaseUrl;
-  }
-
-  return new Promise((resolve, reject) => {
-    const args = ['serve', `--hostname=${DEFAULT_HOST}`, `--port=${DEFAULT_PORT}`];
-    const child = spawn('opencode', args, {
-      env: {
-        ...process.env
-      },
-      stdio: ['ignore', 'pipe', 'pipe']
-    });
-
-    managedServerProcess = child;
-    let combinedOutput = '';
-    let settled = false;
-
-    const finish = (error, baseUrl) => {
-      if (settled) return;
-      settled = true;
-      clearInterval(pollTimer);
-      clearTimeout(startTimeout);
-
-      if (error) {
-        reject(error);
-      } else {
-        resolve(baseUrl);
-      }
-    };
-
-    const processOutputChunk = (chunk) => {
-      const text = chunk.toString();
-      combinedOutput += text;
-      const parsedUrl = parseServerUrlFromOutput(text);
-      if (parsedUrl) {
-        resolvedBaseUrl = parsedUrl;
-        finish(null, resolvedBaseUrl);
-      }
-    };
-
-    child.stdout?.on('data', processOutputChunk);
-    child.stderr?.on('data', processOutputChunk);
-
-    child.on('error', (error) => {
-      if (error?.code === 'ENOENT') {
-        finish(new Error('OpenCode CLI not found. Please install `opencode` first.'));
-      } else {
-        finish(error);
-      }
-    });
-
-    child.on('exit', (code) => {
-      managedServerProcess = null;
-      if (!settled) {
-        const output = combinedOutput.trim();
-        finish(new Error(
-          `OpenCode server exited with code ${code}.${output ? `\n${output}` : ''}`
-        ));
-      }
-    });
-
-    const pollTimer = setInterval(async () => {
-      const healthy = await checkServerHealth(resolvedBaseUrl, 1200);
-      if (healthy) {
-        finish(null, resolvedBaseUrl);
-      }
-    }, 350);
-
-    const startTimeout = setTimeout(() => {
-      finish(new Error(`Timeout waiting for OpenCode server startup (${DEFAULT_PORT})`));
-    }, 15000);
-  });
-}
-
-export async function ensureOpencodeServerReady() {
-  const healthy = await checkServerHealth(resolvedBaseUrl);
-  if (healthy) {
-    return resolvedBaseUrl;
-  }
-
-  if (EXTERNAL_BASE_URL) {
-    throw new Error(`OpenCode server is unreachable at ${EXTERNAL_BASE_URL}`);
-  }
-
-  if (!serverStartPromise) {
-    serverStartPromise = startManagedServer().finally(() => {
-      serverStartPromise = null;
-    });
-  }
-
-  return serverStartPromise;
-}
-
-export async function getOpencodeClient(options = {}) {
-  const { directory = null } = options;
-  const baseUrl = await ensureOpencodeServerReady();
-  return createOpencodeClient(buildClientOptions(baseUrl, directory));
-}
-
-export function resolveOpencodeModel(modelValue) {
-  if (modelValue && typeof modelValue === 'object' && modelValue.providerID && modelValue.modelID) {
-    return {
-      providerID: modelValue.providerID,
-      modelID: modelValue.modelID
-    };
-  }
-
-  const normalized = typeof modelValue === 'string' && modelValue.trim()
-    ? modelValue.trim()
-    : DEFAULT_MODEL;
-
-  if (normalized.includes('/')) {
-    const [providerID, ...rest] = normalized.split('/');
-    return {
-      providerID,
-      modelID: rest.join('/')
-    };
-  }
-
-  return {
-    providerID: 'opencode',
-    modelID: normalized
-  };
-}
-
-function toIsoTime(value, fallback = null) {
-  if (typeof value === 'number' && Number.isFinite(value)) {
-    return new Date(value).toISOString();
-  }
-
-  if (typeof value === 'string' && value.trim()) {
-    const parsed = Date.parse(value);
-    if (!Number.isNaN(parsed)) {
-      return new Date(parsed).toISOString();
-    }
-  }
-
-  return fallback;
-}
-
-function normalizeToolName(rawToolName = 'tool') {
-  if (rawToolName === 'bash') return 'Bash';
-  return rawToolName;
-}
-
-function stringifyToolInput(input) {
-  if (input == null) return '';
-  if (typeof input === 'string') return input;
-
-  if (input.command && typeof input.command === 'string') {
-    return JSON.stringify({ command: input.command });
-  }
-
-  try {
-    return JSON.stringify(input);
-  } catch {
-    return String(input);
-  }
-}
-
-function stringifyToolOutput(output) {
-  if (output == null) return '';
-  if (typeof output === 'string') return output;
-  try {
-    return JSON.stringify(output);
-  } catch {
-    return String(output);
-  }
-}
-
-export async function listOpencodeSessions(projectPath, options = {}) {
-  const { limit = 5 } = options;
-  const client = await getOpencodeClient({ directory: projectPath });
-  const response = await client.session.list({ query: { directory: projectPath } });
-
-  const sessions = Array.isArray(response?.data) ? response.data : [];
-
-  const normalized = sessions
-    .map((session) => ({
-      id: session.id,
-      summary: session.title || 'OpenCode Session',
-      name: session.title || 'OpenCode Session',
-      messageCount: 0,
-      createdAt: toIsoTime(session.time?.created, new Date().toISOString()),
-      lastActivity: toIsoTime(session.time?.updated, new Date().toISOString()),
-      cwd: session.directory || projectPath,
-      provider: 'opencode'
-    }))
-    .sort((left, right) => new Date(right.lastActivity) - new Date(left.lastActivity));
-
-  return limit > 0 ? normalized.slice(0, limit) : normalized;
-}
-
-function extractTokenUsageFromMessageInfo(info) {
-  const tokens = info?.tokens;
-  if (!tokens) return null;
-
-  const input = Number(tokens.input || 0);
-  const output = Number(tokens.output || 0);
-  const reasoning = Number(tokens.reasoning || 0);
-  const cacheRead = Number(tokens.cache?.read || 0);
-  const cacheWrite = Number(tokens.cache?.write || 0);
-
-  return {
-    used: input + output + reasoning + cacheRead + cacheWrite,
-    total: 0,
-    percentage: null,
-    unsupported: true,
-    message: 'OpenCode token total is unavailable from current API payload',
-    breakdown: {
-      input,
-      output,
-      reasoning,
-      cacheRead,
-      cacheCreation: cacheWrite
-    }
-  };
-}
-
-function convertOpencodeMessageEntries(entries = []) {
-  const messages = [];
-  let latestTokenUsage = null;
-
-  for (const entry of entries) {
-    const info = entry?.info || {};
-    const parts = Array.isArray(entry?.parts) ? entry.parts : [];
-    const fallbackTimestamp = new Date().toISOString();
-    const createdAt = toIsoTime(info.time?.created, fallbackTimestamp);
-
-    if (info.role === 'user') {
-      const textParts = parts
-        .filter((part) => part?.type === 'text' && typeof part.text === 'string')
-        .map((part) => part.text)
-        .filter(Boolean);
-
-      if (textParts.length > 0) {
-        messages.push({
-          timestamp: createdAt,
-          message: {
-            role: 'user',
-            content: textParts.join('\n')
-          }
-        });
-      }
-
-      continue;
-    }
-
-    if (info.role !== 'assistant') {
-      continue;
-    }
-
-    const textParts = parts
-      .filter((part) => part?.type === 'text' && typeof part.text === 'string')
-      .map((part) => part.text)
-      .filter(Boolean);
-
-    if (textParts.length > 0) {
-      messages.push({
-        timestamp: createdAt,
-        message: {
-          role: 'assistant',
-          content: textParts.join('\n')
-        }
-      });
-    }
-
-    for (const part of parts) {
-      if (part?.type === 'reasoning' && typeof part.text === 'string' && part.text.trim()) {
-        messages.push({
-          type: 'thinking',
-          timestamp: createdAt,
-          message: {
-            role: 'assistant',
-            content: part.text
-          }
-        });
-      }
-
-      if (part?.type !== 'tool') {
-        continue;
-      }
-
-      const toolCallId = part.callID || part.id;
-      const toolName = normalizeToolName(part.tool);
-      const toolInput = stringifyToolInput(part.state?.input || {});
-      const status = part.state?.status;
-
-      messages.push({
-        type: 'tool_use',
-        timestamp: createdAt,
-        toolName,
-        toolInput,
-        toolCallId
-      });
-
-      if (status !== 'completed' && status !== 'failed') {
-        continue;
-      }
-
-      const output = part.state?.output ?? part.state?.metadata?.output;
-      if (output !== undefined && output !== null) {
-        const toolTimestamp = toIsoTime(part.state?.time?.end, createdAt);
-        messages.push({
-          type: 'tool_result',
-          timestamp: toolTimestamp,
-          toolCallId,
-          output: stringifyToolOutput(output)
-        });
-      }
-    }
-
-    if (info.error?.data?.message) {
-      messages.push({
-        timestamp: createdAt,
-        type: 'error',
-        message: {
-          role: 'error',
-          content: info.error.data.message
-        }
-      });
-    }
-
-    const tokenUsage = extractTokenUsageFromMessageInfo(info);
-    if (tokenUsage) {
-      latestTokenUsage = tokenUsage;
-    }
-  }
-
-  messages.sort((left, right) => new Date(left.timestamp || 0) - new Date(right.timestamp || 0));
-  return { messages, tokenUsage: latestTokenUsage };
-}
-
-export async function getOpencodeSessionMessages(sessionId, options = {}) {
-  const {
-    directory = null,
-    limit = null,
-    offset = 0
-  } = options;
-
-  const client = await getOpencodeClient({ directory });
-  const response = await client.session.messages({
-    path: { id: sessionId },
-    query: directory ? { directory } : undefined
-  });
-
-  const entries = Array.isArray(response?.data) ? response.data : [];
-  const { messages, tokenUsage } = convertOpencodeMessageEntries(entries);
-
-  const total = messages.length;
-
-  if (limit !== null) {
-    const safeLimit = Math.max(0, Number(limit) || 0);
-    const safeOffset = Math.max(0, Number(offset) || 0);
-    const startIndex = Math.max(0, total - safeOffset - safeLimit);
-    const endIndex = Math.max(0, total - safeOffset);
-    const page = messages.slice(startIndex, endIndex);
-
-    return {
-      messages: page,
-      total,
-      hasMore: startIndex > 0,
-      offset: safeOffset,
-      limit: safeLimit,
-      tokenUsage
-    };
-  }
-
-  return {
-    messages,
-    total,
-    hasMore: false,
-    tokenUsage
-  };
-}
-
-export async function deleteOpencodeSession(sessionId, options = {}) {
-  const { directory = null } = options;
-  const client = await getOpencodeClient({ directory });
-  const response = await client.session.delete({
-    path: { id: sessionId },
-    query: directory ? { directory } : undefined
-  });
-
-  if (response?.error) {
-    throw new Error(response.error.message || 'Failed to delete OpenCode session');
-  }
-
-  return response?.data === true;
-}
-
-export async function listOpencodeModels(options = {}) {
-  const { directory = null } = options;
-  const client = await getOpencodeClient({ directory });
-  const response = await client.config.providers({
-    query: directory ? { directory } : undefined
-  });
-
-  const payload = response?.data || {};
-  const providers = Array.isArray(payload.providers) ? payload.providers : [];
-  const modelOptions = [];
-
-  for (const provider of providers) {
-    const providerId = provider?.id;
-    if (!providerId || !provider?.models || typeof provider.models !== 'object') {
-      continue;
-    }
-
-    const providerName = provider.name || providerId;
-
-    for (const [modelKey, modelConfig] of Object.entries(provider.models)) {
-      const modelId = modelConfig?.id || modelKey;
-      const displayName = modelConfig?.name || modelId;
-      modelOptions.push({
-        value: `${providerId}/${modelId}`,
-        label: `${displayName} (${providerName})`
-      });
-    }
-  }
-
-  const uniqueOptions = Array.from(
-    new Map(modelOptions.map((option) => [option.value, option])).values()
-  );
-
-  const defaultModel = (() => {
-    const defaults = payload.default;
-    if (defaults && typeof defaults === 'object') {
-      const values = Object.values(defaults).filter((value) => typeof value === 'string' && value.includes('/'));
-      if (values.length > 0) {
-        return values[0];
-      }
-    }
-
-    if (uniqueOptions.length > 0) {
-      return uniqueOptions[0].value;
-    }
-
-    return DEFAULT_MODEL;
-  })();
-
-  if (uniqueOptions.length === 0) {
-    uniqueOptions.push({
-      value: DEFAULT_MODEL,
-      label: 'GPT-5 Nano (OpenCode)'
-    });
-  }
-
-  return {
-    options: uniqueOptions,
-    defaultModel
-  };
-}
-
-export async function getOpencodeStatus() {
-  let cliVersion = null;
-  let cliAvailable = false;
-
-  try {
-    const version = await new Promise((resolve, reject) => {
-      const child = spawn('opencode', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
-      let stdout = '';
-      let stderr = '';
-
-      child.stdout?.on('data', (chunk) => {
-        stdout += chunk.toString();
-      });
-      child.stderr?.on('data', (chunk) => {
-        stderr += chunk.toString();
-      });
-
-      child.on('error', reject);
-      child.on('close', (code) => {
-        if (code === 0) {
-          resolve(stdout.trim() || stderr.trim());
-        } else {
-          reject(new Error(stderr.trim() || `Exited with ${code}`));
-        }
-      });
-    });
-
-    cliVersion = version;
-    cliAvailable = true;
-  } catch {
-    cliVersion = null;
-    cliAvailable = false;
-  }
-
-  let serverHealthy = false;
-  let serverUrl = resolvedBaseUrl;
-  let serverError = null;
-
-  try {
-    serverUrl = await ensureOpencodeServerReady();
-    serverHealthy = true;
-  } catch (error) {
-    serverHealthy = false;
-    serverError = error.message;
-  }
-
-  const authCandidates = [
-    path.join(os.homedir(), '.local', 'share', 'opencode', 'auth.json'),
-    path.join(os.homedir(), '.config', 'opencode', 'auth.json')
-  ];
-
-  let hasAuthFile = false;
-  for (const filePath of authCandidates) {
-    try {
-      const content = await fs.readFile(filePath, 'utf8');
-      const parsed = JSON.parse(content);
-      if (parsed && typeof parsed === 'object' && Object.keys(parsed).length > 0) {
-        hasAuthFile = true;
-        break;
-      }
-    } catch {
-      // Continue checking next location
-    }
-  }
-
-  const hasEnvKey = Boolean(process.env.OPENCODE_API_KEY || process.env.OPENROUTER_API_KEY);
-  const authenticated = cliAvailable && (hasAuthFile || hasEnvKey);
-
-  return {
-    authenticated,
-    email: authenticated ? 'Configured' : null,
-    cliAvailable,
-    cliVersion,
-    serverHealthy,
-    serverUrl,
-    error: serverError
-  };
-}
-