binary-collections 2.0.13 → 2.0.15

package/lib/opencode/install-opencode-plugins-cli.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/opencode/install-opencode-plugins-cli.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const upath_1 = __importDefault(require("upath"));
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+// Paths relative to current working directory
+const gitCloneDest = '.opencode/plugins/opencode-request-logger';
+const commands = [
+    {
+        cmd: 'git',
+        args: ['clone', 'https://github.com/Opencode-DCP/opencode-request-logger.git', gitCloneDest],
+        skipIfExists: gitCloneDest
+    },
+    {
+        // Run after clone (or if folder already exists) to register the local plugin
+        cmd: 'opencode',
+        args: ['plugin', '.opencode/plugins/opencode-request-logger']
+    },
+    {
+        cmd: 'opencode',
+        args: [
+            'plugin',
+            'opencode-agent-memory@https://github.com/dimaslanjaka/opencode-file-memory/raw/refs/heads/main/release/opencode-agent-memory.tgz'
+        ]
+    },
+    { cmd: 'opencode', args: ['plugin', '@tarquinen/opencode-smart-title@latest'] },
+    { cmd: 'opencode', args: ['plugin', 'oh-my-opencode-slim@latest'] },
+    { cmd: 'opencode', args: ['plugin', '@tarquinen/opencode-dcp@latest'] },
+    { cmd: 'opencode', args: ['plugin', 'envsitter-guard@latest'] }
+];
+function runCommand(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ cmd, args, skipIfExists }) {
+        if (skipIfExists) {
+            const folderPath = upath_1.default.resolve(skipIfExists);
+            if (yield fs_extra_1.default.pathExists(folderPath)) {
+                console.log(`\nSkipping: ${cmd} ${args.join(' ')} (folder exists: ${folderPath})`);
+                return;
+            }
+        }
+        console.log(`\nRunning: ${cmd} ${args.join(' ')}`);
+        yield new Promise((resolve, reject) => {
+            const child = (0, cross_spawn_1.default)(cmd, args, { stdio: 'inherit', shell: true });
+            child.on('close', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`${cmd} exited with code ${code}`));
+            });
+        });
+    });
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            for (const command of commands) {
+                yield runCommand(command);
+            }
+            console.log('\nAll commands executed successfully!');
+        }
+        catch (err) {
+            console.error('\nError executing commands:', err);
+            process.exit(1);
+        }
+    });
+}
+main();

package/lib/opencode/install-opencode-plugins-cli.mjs

@@ -0,0 +1,65 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/opencode/install-opencode-plugins-cli.ts
+init_esm_shims();
+import fs from "fs-extra";
+import path from "upath";
+import spawn from "cross-spawn";
+var gitCloneDest = ".opencode/plugins/opencode-request-logger";
+var commands = [
+  {
+    cmd: "git",
+    args: ["clone", "https://github.com/Opencode-DCP/opencode-request-logger.git", gitCloneDest],
+    skipIfExists: gitCloneDest
+  },
+  {
+    // Run after clone (or if folder already exists) to register the local plugin
+    cmd: "opencode",
+    args: ["plugin", ".opencode/plugins/opencode-request-logger"]
+  },
+  {
+    cmd: "opencode",
+    args: [
+      "plugin",
+      "opencode-agent-memory@https://github.com/dimaslanjaka/opencode-file-memory/raw/refs/heads/main/release/opencode-agent-memory.tgz"
+    ]
+  },
+  { cmd: "opencode", args: ["plugin", "@tarquinen/opencode-smart-title@latest"] },
+  { cmd: "opencode", args: ["plugin", "oh-my-opencode-slim@latest"] },
+  { cmd: "opencode", args: ["plugin", "@tarquinen/opencode-dcp@latest"] },
+  { cmd: "opencode", args: ["plugin", "envsitter-guard@latest"] }
+];
+async function runCommand({ cmd, args, skipIfExists }) {
+  if (skipIfExists) {
+    const folderPath = path.resolve(skipIfExists);
+    if (await fs.pathExists(folderPath)) {
+      console.log(`
+Skipping: ${cmd} ${args.join(" ")} (folder exists: ${folderPath})`);
+      return;
+    }
+  }
+  console.log(`
+Running: ${cmd} ${args.join(" ")}`);
+  await new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: "inherit", shell: true });
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${cmd} exited with code ${code}`));
+    });
+  });
+}
+async function main() {
+  try {
+    for (const command of commands) {
+      await runCommand(command);
+    }
+    console.log("\nAll commands executed successfully!");
+  } catch (err) {
+    console.error("\nError executing commands:", err);
+    process.exit(1);
+  }
+}
+main();

package/lib/opencode/opencode-zen.runner.cjs

@@ -0,0 +1,48 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/opencode/opencode-zen.runner.mjs
+var import_openai = __toESM(require("openai"), 1);
+var import_axios = __toESM(require("axios"), 1);
+var client = new import_openai.default({
+  apiKey: "sk-9aLZhac0dYGY2v37HTBBAo6glifcRZLUNJmh8NaoRN5VOnPlGQ2kh53mBZY32inV",
+  baseURL: "https://opencode.ai/zen/v1"
+  // OpenCode Zen base URL
+});
+async function callZen(prompt) {
+  const res = await import_axios.default.post(
+    "https://opencode.ai/zen/v1/chat/completions",
+    {
+      model: "deepseek-v4-flash-free",
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: 512
+    },
+    {
+      headers: { Authorization: `Bearer ${client.apiKey}` }
+    }
+  );
+  const message = res.data.choices[0].message;
+  const output = message.content || message.reasoning_content;
+  console.log(output);
+}
+callZen("Hello");

package/lib/opencode/opencode-zen.runner.d.mts

@@ -0,0 +1 @@
+export {};

package/lib/opencode/opencode-zen.runner.mjs

@@ -0,0 +1,31 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/opencode/opencode-zen.runner.mjs
+init_esm_shims();
+import OpenAI from "openai";
+import axios from "axios";
+var client = new OpenAI({
+  apiKey: "sk-9aLZhac0dYGY2v37HTBBAo6glifcRZLUNJmh8NaoRN5VOnPlGQ2kh53mBZY32inV",
+  baseURL: "https://opencode.ai/zen/v1"
+  // OpenCode Zen base URL
+});
+async function callZen(prompt) {
+  const res = await axios.post(
+    "https://opencode.ai/zen/v1/chat/completions",
+    {
+      model: "deepseek-v4-flash-free",
+      messages: [{ role: "user", content: prompt }],
+      max_tokens: 512
+    },
+    {
+      headers: { Authorization: `Bearer ${client.apiKey}` }
+    }
+  );
+  const message = res.data.choices[0].message;
+  const output = message.content || message.reasoning_content;
+  console.log(output);
+}
+callZen("Hello");

package/lib/opencode/sqlite.cjs

@@ -0,0 +1,114 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/opencode/sqlite.ts
+var sqlite_exports = {};
+__export(sqlite_exports, {
+  DEFAULT_DB_PATH: () => DEFAULT_DB_PATH,
+  SQLite: () => SQLite
+});
+module.exports = __toCommonJS(sqlite_exports);
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_upath = __toESM(require("upath"), 1);
+var DEFAULT_DB_PATH = import_upath.default.join(process.cwd(), "data", "database", "db.sqlite");
+var SQLite = class {
+  constructor(dbPath = DEFAULT_DB_PATH) {
+    const dir = import_upath.default.dirname(dbPath);
+    if (!import_fs_extra.default.existsSync(dir)) {
+      import_fs_extra.default.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new import_better_sqlite3.default(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("temp_store = MEMORY");
+    this.db.pragma("foreign_keys = ON");
+  }
+  // -------------------------
+  // Migration / schema init
+  // -------------------------
+  migrate(schemaFilePath) {
+    const schema = import_fs_extra.default.readFileSync(schemaFilePath, "utf-8");
+    this.db.exec(schema);
+  }
+  // -------------------------
+  // Core query helpers
+  // -------------------------
+  prepare(sql) {
+    return this.db.prepare(sql);
+  }
+  get(sql, params = {}) {
+    return this.db.prepare(sql).get(params);
+  }
+  all(sql, params = {}) {
+    return this.db.prepare(sql).all(params);
+  }
+  run(sql, params = {}) {
+    return this.db.prepare(sql).run(params);
+  }
+  // -------------------------
+  // Transactions
+  // -------------------------
+  transaction(fn) {
+    const trx = this.db.transaction(fn);
+    return trx();
+  }
+  // -------------------------
+  // Upsert helper (very useful for build cache)
+  // -------------------------
+  upsert(sql, params = {}) {
+    return this.db.prepare(sql).run(params);
+  }
+  // -------------------------
+  // Bulk insert helper
+  // -------------------------
+  insertMany(sql, rows) {
+    const stmt = this.db.prepare(sql);
+    const trx = this.db.transaction((rows2) => {
+      for (const row of rows2) {
+        stmt.run(row);
+      }
+    });
+    trx(rows);
+  }
+  // -------------------------
+  // Utility
+  // -------------------------
+  close() {
+    this.db.close();
+  }
+  // Raw access if needed (escape hatch)
+  raw() {
+    return this.db;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DB_PATH,
+  SQLite
+});

package/lib/opencode/sqlite.d.ts

@@ -0,0 +1,18 @@
+import Database from 'better-sqlite3';
+export type QueryParams = Record<string, any>;
+export type SQLiteDatabase = InstanceType<typeof Database>;
+export declare const DEFAULT_DB_PATH: string;
+export declare class SQLite {
+    private db;
+    constructor(dbPath?: string);
+    migrate(schemaFilePath: string): void;
+    prepare<T = any>(sql: string): T;
+    get<T = any>(sql: string, params?: QueryParams): T | undefined;
+    all<T = any>(sql: string, params?: QueryParams): T[];
+    run(sql: string, params?: QueryParams): Database.RunResult;
+    transaction<T>(fn: () => T): T;
+    upsert(sql: string, params?: QueryParams): Database.RunResult;
+    insertMany(sql: string, rows: QueryParams[]): void;
+    close(): void;
+    raw(): SQLiteDatabase;
+}

package/lib/opencode/sqlite.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLite = exports.DEFAULT_DB_PATH = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const upath_1 = __importDefault(require("upath"));
+exports.DEFAULT_DB_PATH = upath_1.default.join(process.cwd(), 'data', 'database', 'db.sqlite');
+class SQLite {
+    constructor(dbPath = exports.DEFAULT_DB_PATH) {
+        const dir = upath_1.default.dirname(dbPath);
+        if (!fs_extra_1.default.existsSync(dir)) {
+            fs_extra_1.default.mkdirSync(dir, { recursive: true });
+        }
+        this.db = new better_sqlite3_1.default(dbPath);
+        // Performance pragmas (important for SSG workloads)
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('synchronous = NORMAL');
+        this.db.pragma('temp_store = MEMORY');
+        this.db.pragma('foreign_keys = ON');
+    }
+    // -------------------------
+    // Migration / schema init
+    // -------------------------
+    migrate(schemaFilePath) {
+        const schema = fs_extra_1.default.readFileSync(schemaFilePath, 'utf-8');
+        this.db.exec(schema);
+    }
+    // -------------------------
+    // Core query helpers
+    // -------------------------
+    prepare(sql) {
+        return this.db.prepare(sql);
+    }
+    get(sql, params = {}) {
+        return this.db.prepare(sql).get(params);
+    }
+    all(sql, params = {}) {
+        return this.db.prepare(sql).all(params);
+    }
+    run(sql, params = {}) {
+        return this.db.prepare(sql).run(params);
+    }
+    // -------------------------
+    // Transactions
+    // -------------------------
+    transaction(fn) {
+        const trx = this.db.transaction(fn);
+        return trx();
+    }
+    // -------------------------
+    // Upsert helper (very useful for build cache)
+    // -------------------------
+    upsert(sql, params = {}) {
+        return this.db.prepare(sql).run(params);
+    }
+    // -------------------------
+    // Bulk insert helper
+    // -------------------------
+    insertMany(sql, rows) {
+        const stmt = this.db.prepare(sql);
+        const trx = this.db.transaction((rows) => {
+            for (const row of rows) {
+                stmt.run(row);
+            }
+        });
+        trx(rows);
+    }
+    // -------------------------
+    // Utility
+    // -------------------------
+    close() {
+        this.db.close();
+    }
+    // Raw access if needed (escape hatch)
+    raw() {
+        return this.db;
+    }
+}
+exports.SQLite = SQLite;

package/lib/opencode/sqlite.mjs

@@ -0,0 +1,10 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  DEFAULT_DB_PATH,
+  SQLite
+} from "../chunk-56BVU63B.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  DEFAULT_DB_PATH,
+  SQLite
+};

package/lib/opencode/storage.cjs

@@ -0,0 +1,124 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/opencode/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  AUTH_PATH: () => AUTH_PATH,
+  CACHE_DIR: () => CACHE_DIR,
+  CONFIG_DIR: () => CONFIG_DIR,
+  DATABASE_PATH: () => DATABASE_PATH,
+  LOG_DIR: () => LOG_DIR,
+  OPCODE_DIR: () => OPCODE_DIR,
+  PROJECT_DIR: () => PROJECT_DIR,
+  SESSION_DIFF_DIR: () => SESSION_DIFF_DIR,
+  SESSION_PATH: () => SESSION_PATH,
+  STORAGE_PATH: () => STORAGE_PATH,
+  getOpenCodeAuth: () => getOpenCodeAuth,
+  getSessionFileById: () => getSessionFileById,
+  readJson: () => readJson,
+  saveOpenCodeAuth: () => saveOpenCodeAuth,
+  scanDirs: () => scanDirs,
+  scanJson: () => scanJson
+});
+module.exports = __toCommonJS(storage_exports);
+var import_upath = __toESM(require("upath"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_fs_extra = __toESM(require("fs-extra"), 1);
+var import_jsonc_parser = require("jsonc-parser");
+var OPCODE_DIR = import_upath.default.join(import_os.default.homedir(), ".local/share/opencode");
+var CONFIG_DIR = import_upath.default.join(import_os.default.homedir(), ".config/opencode");
+var CACHE_DIR = import_upath.default.join(import_os.default.homedir(), ".cache/opencode");
+var LOG_DIR = import_upath.default.join(OPCODE_DIR, "log");
+var AUTH_PATH = import_upath.default.join(OPCODE_DIR, "auth.json");
+var PROJECT_DIR = import_upath.default.join(OPCODE_DIR, "project");
+var STORAGE_PATH = import_upath.default.join(OPCODE_DIR, "storage");
+var SESSION_PATH = import_upath.default.join(STORAGE_PATH, "session");
+var SESSION_DIFF_DIR = import_upath.default.join(STORAGE_PATH, "session_diff");
+var DATABASE_PATH = import_upath.default.join(OPCODE_DIR, "opencode.db");
+async function scanJson(dir) {
+  const results = [];
+  try {
+    const entries = await import_fs_extra.default.readdir(dir);
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      const content = await import_fs_extra.default.readFile(import_upath.default.join(dir, entry), "utf-8");
+      results.push(JSON.parse(content));
+    }
+  } catch {
+  }
+  return results;
+}
+async function scanDirs(dir) {
+  try {
+    const entries = await import_fs_extra.default.readdir(dir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+async function readJson(filePath) {
+  try {
+    const content = await import_fs_extra.default.readFile(filePath, "utf-8");
+    return (0, import_jsonc_parser.parse)(content);
+  } catch {
+    return null;
+  }
+}
+function getSessionFileById(sessionId) {
+  return import_upath.default.join(SESSION_DIFF_DIR, `${sessionId}.json`);
+}
+function getOpenCodeAuth() {
+  const file = import_upath.default.join(OPCODE_DIR, "auth.json");
+  if (!import_fs_extra.default.existsSync(file)) return null;
+  return readJson(file);
+}
+async function saveOpenCodeAuth(auth) {
+  const file = import_upath.default.join(OPCODE_DIR, "auth.json");
+  await import_fs_extra.default.ensureFile(file);
+  await import_fs_extra.default.writeFile(file, JSON.stringify(auth, null, 2), "utf-8");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTH_PATH,
+  CACHE_DIR,
+  CONFIG_DIR,
+  DATABASE_PATH,
+  LOG_DIR,
+  OPCODE_DIR,
+  PROJECT_DIR,
+  SESSION_DIFF_DIR,
+  SESSION_PATH,
+  STORAGE_PATH,
+  getOpenCodeAuth,
+  getSessionFileById,
+  readJson,
+  saveOpenCodeAuth,
+  scanDirs,
+  scanJson
+});

package/lib/opencode/storage.d.ts

@@ -0,0 +1,27 @@
+import { OpenCodeAuthData } from './types.js';
+/** Root data directory (`~/.local/share/opencode`). */
+export declare const OPCODE_DIR: string;
+/** Config directory (`~/.config/opencode`). */
+export declare const CONFIG_DIR: string;
+/** Cache directory (`~/.cache/opencode`). */
+export declare const CACHE_DIR: string;
+/** Logs directory. */
+export declare const LOG_DIR: string;
+/** Path to the auth JSON file. */
+export declare const AUTH_PATH: string;
+/** Project storage directory (sessions, messages). */
+export declare const PROJECT_DIR: string;
+/** @deprecated Legacy storage sub-path. Use `OPCODE_DIR` or `PROJECT_DIR` instead. */
+export declare const STORAGE_PATH: string;
+/** @deprecated Legacy session sub-path. Use `PROJECT_DIR` instead. */
+export declare const SESSION_PATH: string;
+/** Session diff directory. */
+export declare const SESSION_DIFF_DIR: string;
+/** Path to the OpenCode database. */
+export declare const DATABASE_PATH: string;
+export declare function scanJson<T>(dir: string): Promise<T[]>;
+export declare function scanDirs(dir: string): Promise<string[]>;
+export declare function readJson<T>(filePath: string): Promise<T | null>;
+export declare function getSessionFileById(sessionId: string): string;
+export declare function getOpenCodeAuth(): Promise<OpenCodeAuthData>;
+export declare function saveOpenCodeAuth(auth: OpenCodeAuthData): Promise<void>;