@vantran-se/openchamber-web 1.24.4 → 2.0.1

package/server/lib/opencode/auth.js

@@ -1,16 +1,36 @@
+/**
+ * READ-ONLY view of OpenCode's provider credentials.
+ *
+ * OpenCode 2.x imports the legacy `auth.json` once into its own database and
+ * never writes the file again; credentials live behind `/api/integration` and
+ * `/api/credential`, and there is no HTTP route that hands a key back.
+ * OpenChamber needs the raw credential for provider quota lookups, voice keys
+ * and the GitHub and Linear helpers, so `readAuthFile()` answers from the
+ * database OpenCode actually uses (`credential-db.js`). A successful database
+ * read is authoritative, including an empty one: OpenCode never clears
+ * `auth.json` after importing it, and a credential the user removed in
+ * OpenCode disappears only from the database, so mixing the file back in
+ * would hand out the deleted key again. The legacy file is read only when the
+ * database cannot be read at all (no sqlite runtime, no file, unknown
+ * schema). The shape is the legacy `auth.json` map either way. Nothing here
+ * writes: a write would be invisible to the running OpenCode and drift from
+ * what it uses.
+ */
+
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { readCredentialsFromDb, resolveCredentialDbPath } from './credential-db.js';
 
 const OPENCODE_DATA_DIR = path.join(os.homedir(), '.local', 'share', 'opencode');
 const AUTH_FILE = path.join(OPENCODE_DATA_DIR, 'auth.json');
 
-function readAuthFile() {
-  if (!fs.existsSync(AUTH_FILE)) {
+function readLegacyAuthFile(authFile, fileSystem) {
+  if (!fileSystem.existsSync(authFile)) {
     return {};
   }
   try {
-    const content = fs.readFileSync(AUTH_FILE, 'utf8');
+    const content = fileSystem.readFileSync(authFile, 'utf8');
     const trimmed = content.trim();
     if (!trimmed) {
       return {};
@@ -22,45 +42,24 @@ function readAuthFile() {
   }
 }
 
-function writeAuthFile(auth) {
-  try {
-    if (!fs.existsSync(OPENCODE_DATA_DIR)) {
-      fs.mkdirSync(OPENCODE_DATA_DIR, { recursive: true, mode: 0o700 });
-    }
-    if (process.platform !== 'win32') fs.chmodSync(OPENCODE_DATA_DIR, 0o700);
-
-    if (fs.existsSync(AUTH_FILE)) {
-      const backupFile = `${AUTH_FILE}.openchamber.backup`;
-      fs.copyFileSync(AUTH_FILE, backupFile);
-      if (process.platform !== 'win32') fs.chmodSync(backupFile, 0o600);
-      console.log(`Created auth backup: ${backupFile}`);
-    }
-
-    fs.writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2), { encoding: 'utf8', mode: 0o600 });
-    if (process.platform !== 'win32') fs.chmodSync(AUTH_FILE, 0o600);
-    console.log('Successfully wrote auth file');
-  } catch (error) {
-    console.error('Failed to write auth file:', error);
-    throw new Error('Failed to write OpenCode auth configuration');
-  }
-}
-
-function removeProviderAuth(providerId) {
-  if (!providerId || typeof providerId !== 'string') {
-    throw new Error('Provider ID is required');
-  }
-
-  const auth = readAuthFile();
-  
-  if (!auth[providerId]) {
-    console.log(`Provider ${providerId} not found in auth file, nothing to remove`);
-    return false;
-  }
-
-  delete auth[providerId];
-  writeAuthFile(auth);
-  console.log(`Removed provider auth: ${providerId}`);
-  return true;
+/**
+ * The credentials OpenCode uses, keyed by provider id, in the legacy entry
+ * shape. The database answer is authoritative whenever it can be read, `{}`
+ * included; the legacy file is consulted only when it cannot. A corrupt
+ * legacy file therefore never blocks a healthy database, and only throws when
+ * it is the sole source left.
+ *
+ * @param {{ dbPath?: string, authFile?: string, fileSystem?: typeof fs }} [options] test seams; production callers pass nothing.
+ */
+function readAuthFile(options = {}) {
+  const {
+    dbPath = resolveCredentialDbPath({ dataDir: OPENCODE_DATA_DIR, path }),
+    authFile = AUTH_FILE,
+    fileSystem = fs,
+  } = options;
+  const stored = readCredentialsFromDb({ dbPath, fs: fileSystem });
+  if (stored) return stored;
+  return readLegacyAuthFile(authFile, fileSystem);
 }
 
 function getProviderAuth(providerId) {
@@ -75,8 +74,6 @@ function listProviderAuths() {
 
 export {
   readAuthFile,
-  writeAuthFile,
-  removeProviderAuth,
   getProviderAuth,
   listProviderAuths,
   AUTH_FILE,

package/server/lib/opencode/auth.test.js

@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+import { readAuthFile } from './auth.js';
+
+const sqlite = (() => {
+  try {
+    return createRequire(import.meta.url)('node:sqlite');
+  } catch {
+    return null;
+  }
+})();
+
+let dir;
+let dbPath;
+let authFile;
+
+const seedDb = (rows) => {
+  const db = new sqlite.DatabaseSync(dbPath);
+  db.exec(
+    'CREATE TABLE credential (id TEXT PRIMARY KEY, integration_id TEXT, label TEXT NOT NULL, value TEXT NOT NULL, ' +
+      'active INTEGER, time_created INTEGER NOT NULL, time_updated INTEGER NOT NULL)',
+  );
+  const insert = db.prepare(
+    'INSERT INTO credential (id, integration_id, label, value, active, time_created, time_updated) VALUES (?, ?, ?, ?, ?, ?, ?)',
+  );
+  for (const [index, row] of rows.entries()) {
+    insert.run(`c${index}`, row.integration, 'default', JSON.stringify(row.value), 1, 1, 1);
+  }
+  db.close();
+};
+
+const read = () => readAuthFile({ dbPath, authFile, fileSystem: fs });
+
+beforeEach(() => {
+  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'oc-auth-'));
+  dbPath = path.join(dir, 'opencode.db');
+  authFile = path.join(dir, 'auth.json');
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  vi.spyOn(console, 'warn').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe.skipIf(!sqlite)('readAuthFile', () => {
+  it('answers from the database alone when it can be read, so a credential deleted in OpenCode stays deleted', () => {
+    // OpenCode never clears auth.json after importing it; the stale key must not come back.
+    fs.writeFileSync(authFile, JSON.stringify({ openai: { type: 'api', key: 'stale' }, deepseek: { type: 'api', key: 'removed' } }));
+    seedDb([{ integration: 'openai', value: { type: 'key', key: 'fresh' } }]);
+    expect(read()).toEqual({ openai: { type: 'api', key: 'fresh' } });
+  });
+
+  it('treats an empty database as authoritative', () => {
+    fs.writeFileSync(authFile, JSON.stringify({ openai: { type: 'api', key: 'stale' } }));
+    seedDb([]);
+    expect(read()).toEqual({});
+  });
+
+  it('does not let a corrupt legacy file block a healthy database', () => {
+    fs.writeFileSync(authFile, '{ not json');
+    seedDb([{ integration: 'openai', value: { type: 'key', key: 'fresh' } }]);
+    expect(read()).toEqual({ openai: { type: 'api', key: 'fresh' } });
+  });
+
+  it('falls back to the legacy file only when the database is unavailable', () => {
+    fs.writeFileSync(authFile, JSON.stringify({ openai: { type: 'api', key: 'legacy' } }));
+    expect(read()).toEqual({ openai: { type: 'api', key: 'legacy' } });
+  });
+
+  it('falls back to the legacy file when the database schema is not what it expects', () => {
+    const db = new sqlite.DatabaseSync(dbPath);
+    db.exec('CREATE TABLE credential (id TEXT PRIMARY KEY)');
+    db.close();
+    fs.writeFileSync(authFile, JSON.stringify({ openai: { type: 'api', key: 'legacy' } }));
+    expect(read()).toEqual({ openai: { type: 'api', key: 'legacy' } });
+  });
+
+  it('reports a corrupt legacy file when it is the only source left', () => {
+    fs.writeFileSync(authFile, '{ not json');
+    expect(() => read()).toThrow('Failed to read OpenCode auth configuration');
+  });
+
+  it('answers empty with neither source present', () => {
+    expect(read()).toEqual({});
+  });
+});

package/server/lib/opencode/cli-upgrade.d.ts

@@ -0,0 +1,4 @@
+export function runOpenCodeCliUpgrade(
+  launch: { binary: string; args: string[] },
+  options?: { cwd?: string; env?: NodeJS.ProcessEnv },
+): Promise<void>;

package/server/lib/opencode/cli-upgrade.js

@@ -0,0 +1,18 @@
+import { execFile } from 'node:child_process';
+
+// The resolved launch target can be a native CLI or a runtime plus script.
+// No request-supplied command, version, or installer method reaches this process.
+export const runOpenCodeCliUpgrade = (launch, options = {}) => new Promise((resolve, reject) => {
+  const child = execFile(launch.binary, [...launch.args, 'upgrade'], {
+    cwd: options.cwd,
+    env: options.env,
+    windowsHide: true,
+    maxBuffer: 1024 * 1024,
+  }, (error) => {
+    // Installer output can contain registry credentials. Do not log or return it.
+    if (error) reject(new Error('OpenCode CLI upgrade failed. Run opencode upgrade in a terminal for details.'));
+    else resolve();
+  });
+  // Package managers must receive EOF instead of waiting for interactive input.
+  child.stdin?.end();
+});

package/server/lib/opencode/cli-upgrade.test.js

@@ -0,0 +1,36 @@
+import { mkdtemp, writeFile, readFile, rm, realpath } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { describe, it, expect } from 'vitest';
+import { runOpenCodeCliUpgrade } from './cli-upgrade.js';
+
+describe('OpenCode CLI upgrade process', () => {
+  it('runs the resolved executable and wrapper arguments, with EOF and the supplied environment', async () => {
+    const directory = await mkdtemp(path.join(tmpdir(), 'oc upgrade '));
+    try {
+      const script = path.join(directory, 'cli fixture.cjs');
+      const result = path.join(directory, 'result.json');
+      await writeFile(script, `process.stdin.resume(); process.stdin.on('end', () => {
+        require('node:fs').writeFileSync(process.env.RESULT, JSON.stringify({ args: process.argv.slice(2), cwd: process.cwd() }));
+      });`);
+      await runOpenCodeCliUpgrade({ binary: process.execPath, args: [script] }, {
+        cwd: directory, env: { ...process.env, RESULT: result },
+      });
+      expect(JSON.parse(await readFile(result, 'utf8'))).toEqual({ args: ['upgrade'], cwd: await realpath(directory) });
+    } finally { await rm(directory, { recursive: true, force: true }); }
+  });
+
+  it('reports nonzero exits without exposing installer output', async () => {
+    await expect(runOpenCodeCliUpgrade({ binary: process.execPath, args: ['-e', 'console.error("private-registry-token"); process.exit(1)', '--'] }))
+      .rejects.toThrow('OpenCode CLI upgrade failed. Run opencode upgrade in a terminal for details.');
+  });
+
+  it('reports spawn errors', async () => {
+    await expect(runOpenCodeCliUpgrade({ binary: '/nonexistent/opencode-upgrade-fixture', args: [] })).rejects.toThrow('OpenCode CLI upgrade failed');
+  });
+  it('treats a signal exit as failure', async () => {
+    await expect(runOpenCodeCliUpgrade({ binary: process.execPath, args: ['-e', 'process.kill(process.pid, "SIGTERM")', '--'] }))
+      .rejects.toThrow('OpenCode CLI upgrade failed');
+  });
+
+});