@akira-tl/forgerelay 0.1.0

package/dist/config.js

@@ -0,0 +1,224 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { expandHomePath } from "./roots.js";
+import { forgerelayAgentsDir, forgerelaySkillsDir, loadForgeRelayFiles } from "./user-config.js";
+const DEFAULT_OAUTH_ACCESS_TOKEN_TTL_SECONDS = 60 * 60;
+const DEFAULT_OAUTH_REFRESH_TOKEN_TTL_SECONDS = 30 * 24 * 60 * 60;
+const DEFAULT_ARTIFACT_MAX_FILE_BYTES = 100 * 1024 * 1024;
+function parsePort(value) {
+    if (value === undefined || value === "")
+        return 7676;
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`Invalid PORT: ${value}`);
+    }
+    return port;
+}
+function parseAllowedRoots(value) {
+    if (Array.isArray(value)) {
+        const roots = value.map((entry) => entry.trim()).filter(Boolean);
+        return (roots.length > 0 ? roots : [process.cwd()]).map((root) => resolve(expandHomePath(root)));
+    }
+    const rawRoots = value
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean) ?? [];
+    const roots = rawRoots.length > 0 ? rawRoots : [process.cwd()];
+    return roots.map((root) => resolve(expandHomePath(root)));
+}
+function parseAllowedHosts(value, derivedHosts) {
+    if (Array.isArray(value)) {
+        return normalizeAllowedHosts(value, derivedHosts);
+    }
+    const rawHosts = value
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean) ?? [];
+    return normalizeAllowedHosts(rawHosts, derivedHosts);
+}
+function normalizeAllowedHosts(rawHosts, derivedHosts) {
+    const hosts = rawHosts.length > 0 ? rawHosts : derivedHosts;
+    if (hosts.includes("*"))
+        return ["*"];
+    return Array.from(new Set(hosts.map((host) => host.trim()).filter(Boolean)));
+}
+function parseBoolean(value) {
+    return ["1", "true", "yes", "on"].includes(value?.toLowerCase() ?? "");
+}
+function productEnv(env, suffix) {
+    return env[`FORGERELAY_${suffix}`] ?? env[`DEVSPACE_${suffix}`];
+}
+function parseToolMode(env) {
+    const mode = productEnv(env, "TOOL_MODE");
+    if (mode === "minimal" || mode === "full" || mode === "codex")
+        return mode;
+    if (mode)
+        throw new Error(`Invalid FORGERELAY_TOOL_MODE: ${mode}`);
+    const legacyMinimal = productEnv(env, "MINIMAL_TOOLS");
+    if (legacyMinimal !== undefined) {
+        return parseBoolean(legacyMinimal) ? "minimal" : "full";
+    }
+    return "minimal";
+}
+function parseWorkflowInstructions(value, fallback) {
+    const resolved = value !== undefined ? value : fallback;
+    if (resolved === false || resolved === undefined)
+        return resolved;
+    const instructions = resolved.trim();
+    return instructions.length > 0 ? instructions : false;
+}
+function parseAppendInstructions(value, fallback) {
+    const instructions = (value ?? fallback)?.trim();
+    return instructions ? instructions : undefined;
+}
+function parseLogLevel(value) {
+    if (!value || value === "info")
+        return "info";
+    if (["silent", "error", "warn", "debug"].includes(value))
+        return value;
+    throw new Error(`Invalid FORGERELAY_LOG_LEVEL: ${value}`);
+}
+function parseLogFormat(value) {
+    if (!value || value === "json")
+        return "json";
+    if (value === "pretty")
+        return "pretty";
+    throw new Error(`Invalid FORGERELAY_LOG_FORMAT: ${value}`);
+}
+function parsePathList(value) {
+    return (value
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean) ?? []);
+}
+function parseStringList(value, fallback) {
+    const entries = value
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    return entries && entries.length > 0 ? entries : fallback;
+}
+function parsePositiveInteger(value, fallback, name, max = Number.MAX_SAFE_INTEGER) {
+    if (!value)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > max) {
+        throw new Error(`Invalid ${name}: ${value}`);
+    }
+    return parsed;
+}
+function parseLoggingConfig(env) {
+    const requests = productEnv(env, "LOG_REQUESTS");
+    const toolCalls = productEnv(env, "LOG_TOOL_CALLS");
+    return {
+        level: parseLogLevel(productEnv(env, "LOG_LEVEL")),
+        format: parseLogFormat(productEnv(env, "LOG_FORMAT")),
+        requests: requests === undefined ? true : parseBoolean(requests),
+        assets: parseBoolean(productEnv(env, "LOG_ASSETS")),
+        toolCalls: toolCalls === undefined ? true : parseBoolean(toolCalls),
+        shellCommands: parseBoolean(productEnv(env, "LOG_SHELL_COMMANDS")),
+        trustProxy: parseBoolean(productEnv(env, "TRUST_PROXY")),
+    };
+}
+function parseWidgetMode(value) {
+    if (!value || value === "full")
+        return "full";
+    if (value === "off" || value === "changes")
+        return value;
+    throw new Error(`Invalid FORGERELAY_WIDGETS: ${value}`);
+}
+function parseRequiredSecret(value, name) {
+    const secret = value?.trim();
+    if (!secret) {
+        throw new Error(`${name} is required for ForgeRelay OAuth. Run: forgerelay init`);
+    }
+    if (secret.length < 16) {
+        throw new Error(`${name} must be at least 16 characters long.`);
+    }
+    return secret;
+}
+function parseOAuthConfig(env, ownerToken) {
+    return {
+        ownerToken: parseRequiredSecret(productEnv(env, "OAUTH_OWNER_TOKEN") ?? ownerToken, "FORGERELAY_OAUTH_OWNER_TOKEN"),
+        accessTokenTtlSeconds: parsePositiveInteger(productEnv(env, "OAUTH_ACCESS_TOKEN_TTL_SECONDS"), DEFAULT_OAUTH_ACCESS_TOKEN_TTL_SECONDS, "FORGERELAY_OAUTH_ACCESS_TOKEN_TTL_SECONDS"),
+        refreshTokenTtlSeconds: parsePositiveInteger(productEnv(env, "OAUTH_REFRESH_TOKEN_TTL_SECONDS"), DEFAULT_OAUTH_REFRESH_TOKEN_TTL_SECONDS, "FORGERELAY_OAUTH_REFRESH_TOKEN_TTL_SECONDS"),
+        scopes: parseStringList(productEnv(env, "OAUTH_SCOPES"), ["devspace"]),
+        allowedRedirectHosts: parseStringList(productEnv(env, "OAUTH_ALLOWED_REDIRECT_HOSTS"), [
+            "chatgpt.com",
+            "localhost",
+            "127.0.0.1",
+        ]),
+    };
+}
+function defaultStateDir() {
+    const current = join(homedir(), ".local", "share", "forgerelay");
+    const legacy = join(homedir(), ".local", "share", "devspace");
+    return existsSync(current) || !existsSync(legacy) ? current : legacy;
+}
+function defaultWorktreeRoot() {
+    const current = join(homedir(), ".forgerelay", "worktrees");
+    const legacy = join(homedir(), ".devspace", "worktrees");
+    return existsSync(current) || !existsSync(legacy) ? current : legacy;
+}
+function defaultAgentDir() {
+    return join(homedir(), ".codex");
+}
+export function loadConfig(env = process.env) {
+    const files = loadForgeRelayFiles(env);
+    const host = env.HOST ?? files.config.host ?? "127.0.0.1";
+    const port = parsePort(env.PORT ?? files.config.port);
+    const publicBaseUrl = parsePublicBaseUrl(productEnv(env, "PUBLIC_BASE_URL") ?? files.config.publicBaseUrl ?? localPublicBaseUrl(host, port));
+    const derivedAllowedHosts = [
+        "localhost",
+        "127.0.0.1",
+        "::1",
+        host,
+        new URL(publicBaseUrl).hostname,
+        ...(files.config.allowedHosts ?? []),
+    ];
+    return {
+        host,
+        port,
+        oauth: parseOAuthConfig(env, files.auth.ownerToken),
+        allowedRoots: parseAllowedRoots(productEnv(env, "ALLOWED_ROOTS") ?? files.config.allowedRoots),
+        allowedHosts: parseAllowedHosts(productEnv(env, "ALLOWED_HOSTS"), derivedAllowedHosts),
+        publicBaseUrl,
+        toolMode: parseToolMode(env),
+        workflowInstructions: parseWorkflowInstructions(productEnv(env, "WORKFLOW_INSTRUCTIONS"), files.config.workflowInstructions),
+        appendInstructions: parseAppendInstructions(productEnv(env, "APPEND_INSTRUCTIONS"), files.config.appendInstructions),
+        widgets: parseWidgetMode(productEnv(env, "WIDGETS")),
+        stateDir: resolve(expandHomePath(productEnv(env, "STATE_DIR") ?? files.config.stateDir ?? defaultStateDir())),
+        worktreeRoot: resolve(expandHomePath(productEnv(env, "WORKTREE_ROOT") ?? files.config.worktreeRoot ?? defaultWorktreeRoot())),
+        artifactsEnabled: productEnv(env, "ARTIFACTS") === undefined
+            ? files.config.artifactsEnabled === true
+            : parseBoolean(productEnv(env, "ARTIFACTS")),
+        artifactMaxFileBytes: parsePositiveInteger(productEnv(env, "ARTIFACT_MAX_FILE_BYTES") ?? numberConfigValue(files.config.artifactMaxFileBytes), DEFAULT_ARTIFACT_MAX_FILE_BYTES, "FORGERELAY_ARTIFACT_MAX_FILE_BYTES"),
+        skillsEnabled: productEnv(env, "SKILLS") === undefined ? true : parseBoolean(productEnv(env, "SKILLS")),
+        skillPaths: parsePathList(productEnv(env, "SKILL_PATHS")),
+        devspaceSkillsDir: forgerelaySkillsDir(env),
+        devspaceAgentsDir: forgerelayAgentsDir(env),
+        subagents: productEnv(env, "SUBAGENTS") === undefined
+            ? files.config.subagents === true
+            : parseBoolean(productEnv(env, "SUBAGENTS")),
+        agentDir: resolve(expandHomePath(productEnv(env, "AGENT_DIR") ?? files.config.agentDir ?? defaultAgentDir())),
+        logging: parseLoggingConfig(env),
+    };
+}
+function numberConfigValue(value) {
+    return value === undefined ? undefined : String(value);
+}
+function parsePublicBaseUrl(value) {
+    const parsed = new URL(value);
+    parsed.hash = "";
+    parsed.search = "";
+    parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+    return parsed.toString().replace(/\/$/, "");
+}
+function localPublicBaseUrl(host, port) {
+    const publicHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+    const formattedHost = publicHost.includes(":") && !publicHost.startsWith("[")
+        ? `[${publicHost}]`
+        : publicHost;
+    return `http://${formattedHost}:${port}`;
+}

package/dist/db/client.js

@@ -0,0 +1,29 @@
+import { chmodSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema.js";
+import { migrateDatabase } from "./migrations.js";
+export function databasePath(stateDir) {
+    return join(stateDir, "devspace.sqlite");
+}
+export function openDatabase(stateDir) {
+    mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+    chmodSync(stateDir, 0o700);
+    const path = databasePath(stateDir);
+    const sqlite = new Database(path);
+    chmodSync(path, 0o600);
+    sqlite.pragma("journal_mode = WAL");
+    sqlite.pragma("synchronous = NORMAL");
+    sqlite.pragma("busy_timeout = 5000");
+    sqlite.pragma("foreign_keys = ON");
+    migrateDatabase(sqlite);
+    return {
+        sqlite,
+        db: createDrizzleDatabase(sqlite),
+        close: () => sqlite.close(),
+    };
+}
+function createDrizzleDatabase(sqlite) {
+    return drizzle(sqlite, { schema });
+}

package/dist/db/migrations.js

@@ -0,0 +1,189 @@
+const migrations = [
+    {
+        version: 1,
+        name: "workspace-state",
+        up: migrateWorkspaceState,
+    },
+    {
+        version: 2,
+        name: "oauth-state",
+        up: migrateOAuthState,
+    },
+    {
+        version: 3,
+        name: "local-agent-sessions",
+        up: migrateLocalAgentSessions,
+    },
+    {
+        version: 4,
+        name: "workspace-conversation-bindings",
+        up: migrateWorkspaceConversationBindings,
+    },
+    {
+        version: 5,
+        name: "workspace-worktree-branches",
+        up: migrateWorkspaceWorktreeBranches,
+    },
+];
+export function migrateDatabase(sqlite) {
+    const migrate = sqlite.transaction(() => {
+        sqlite.exec(`
+      create table if not exists devspace_schema_migrations (
+        version integer primary key,
+        name text not null,
+        applied_at text not null
+      );
+    `);
+        const applied = new Set(sqlite.prepare("select version from devspace_schema_migrations").all().map((row) => row.version));
+        const recordMigration = sqlite.prepare("insert into devspace_schema_migrations (version, name, applied_at) values (?, ?, ?)");
+        for (const migration of migrations) {
+            if (applied.has(migration.version))
+                continue;
+            migration.up(sqlite);
+            recordMigration.run(migration.version, migration.name, new Date().toISOString());
+        }
+    });
+    migrate.immediate();
+}
+function migrateWorkspaceState(sqlite) {
+    sqlite.exec(`
+    create table if not exists workspace_sessions (
+      id text primary key,
+      root text not null,
+      status text not null default 'active',
+      mode text not null default 'checkout',
+      source_root text,
+      base_ref text,
+      base_sha text,
+      managed text not null default 'false',
+      created_at text not null,
+      last_used_at text not null
+    );
+
+    create index if not exists workspace_sessions_root_idx
+      on workspace_sessions(root, last_used_at desc);
+
+    create index if not exists workspace_sessions_status_idx
+      on workspace_sessions(status, last_used_at desc);
+
+    create table if not exists loaded_agent_files (
+      workspace_session_id text not null,
+      path text not null,
+      content_hash text not null,
+      content text not null,
+      loaded_at text not null,
+      last_seen_at text not null,
+      primary key (workspace_session_id, path),
+      foreign key (workspace_session_id)
+        references workspace_sessions(id)
+        on delete cascade
+    );
+
+    create index if not exists loaded_agent_files_path_idx
+      on loaded_agent_files(path);
+  `);
+    addColumnIfMissing(sqlite, "workspace_sessions", "mode", "text not null default 'checkout'");
+    addColumnIfMissing(sqlite, "workspace_sessions", "source_root", "text");
+    addColumnIfMissing(sqlite, "workspace_sessions", "base_ref", "text");
+    addColumnIfMissing(sqlite, "workspace_sessions", "base_sha", "text");
+    addColumnIfMissing(sqlite, "workspace_sessions", "managed", "text not null default 'false'");
+}
+function migrateOAuthState(sqlite) {
+    sqlite.exec(`
+    create table if not exists oauth_clients (
+      client_id text primary key,
+      client_json text not null,
+      issued_at integer not null
+    );
+
+    create index if not exists oauth_clients_issued_at_idx
+      on oauth_clients(issued_at desc);
+
+    create table if not exists oauth_access_tokens (
+      token_hash text primary key,
+      client_id text not null,
+      scopes_json text not null,
+      expires_at integer not null,
+      resource text,
+      foreign key (client_id) references oauth_clients(client_id) on delete cascade
+    );
+
+    create index if not exists oauth_access_tokens_client_id_idx
+      on oauth_access_tokens(client_id);
+
+    create index if not exists oauth_access_tokens_expires_at_idx
+      on oauth_access_tokens(expires_at);
+
+    create table if not exists oauth_refresh_tokens (
+      token_hash text primary key,
+      client_id text not null,
+      scopes_json text not null,
+      expires_at integer not null,
+      resource text,
+      foreign key (client_id) references oauth_clients(client_id) on delete cascade
+    );
+
+    create index if not exists oauth_refresh_tokens_client_id_idx
+      on oauth_refresh_tokens(client_id);
+
+    create index if not exists oauth_refresh_tokens_expires_at_idx
+      on oauth_refresh_tokens(expires_at);
+  `);
+}
+function migrateLocalAgentSessions(sqlite) {
+    sqlite.exec(`
+    create table if not exists local_agent_sessions (
+      id text primary key,
+      workspace_id text,
+      workspace_root text not null,
+      profile_name text not null,
+      provider text not null,
+      model text,
+      thinking text,
+      provider_session_id text,
+      status text not null,
+      latest_response text,
+      error text,
+      created_at text not null,
+      updated_at text not null
+    );
+
+    create index if not exists local_agent_sessions_workspace_id_idx
+      on local_agent_sessions(workspace_id, updated_at desc);
+
+    create index if not exists local_agent_sessions_workspace_root_idx
+      on local_agent_sessions(workspace_root, updated_at desc);
+
+    create index if not exists local_agent_sessions_provider_session_id_idx
+      on local_agent_sessions(provider_session_id);
+  `);
+    addColumnIfMissing(sqlite, "local_agent_sessions", "thinking", "text");
+}
+function migrateWorkspaceConversationBindings(sqlite) {
+    sqlite.exec(`
+    create table if not exists workspace_conversation_bindings (
+      conversation_scope_id text not null,
+      target_key text not null,
+      workspace_session_id text not null,
+      created_at text not null,
+      last_used_at text not null,
+      primary key (conversation_scope_id, target_key),
+      foreign key (workspace_session_id)
+        references workspace_sessions(id)
+        on delete cascade
+    );
+
+    create index if not exists workspace_conversation_bindings_workspace_idx
+      on workspace_conversation_bindings(workspace_session_id);
+  `);
+}
+function migrateWorkspaceWorktreeBranches(sqlite) {
+    addColumnIfMissing(sqlite, "workspace_sessions", "branch", "text");
+    addColumnIfMissing(sqlite, "workspace_sessions", "target_branch", "text");
+}
+function addColumnIfMissing(sqlite, table, column, definition) {
+    const columns = sqlite.prepare(`pragma table_info(${table})`).all();
+    if (columns.some((existingColumn) => existingColumn.name === column))
+        return;
+    sqlite.exec(`alter table ${table} add column ${column} ${definition}`);
+}

package/dist/db/schema.js

@@ -0,0 +1,85 @@
+import { index, integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+export const workspaceSessions = sqliteTable("workspace_sessions", {
+    id: text("id").primaryKey(),
+    root: text("root").notNull(),
+    status: text("status").notNull().default("active"),
+    mode: text("mode").notNull().default("checkout"),
+    sourceRoot: text("source_root"),
+    baseRef: text("base_ref"),
+    baseSha: text("base_sha"),
+    branch: text("branch"),
+    targetBranch: text("target_branch"),
+    managed: text("managed").notNull().default("false"),
+    createdAt: text("created_at").notNull(),
+    lastUsedAt: text("last_used_at").notNull(),
+}, (table) => [
+    index("workspace_sessions_root_idx").on(table.root, table.lastUsedAt),
+    index("workspace_sessions_status_idx").on(table.status, table.lastUsedAt),
+]);
+export const loadedAgentFiles = sqliteTable("loaded_agent_files", {
+    workspaceSessionId: text("workspace_session_id")
+        .notNull()
+        .references(() => workspaceSessions.id, { onDelete: "cascade" }),
+    path: text("path").notNull(),
+    contentHash: text("content_hash").notNull(),
+    content: text("content").notNull(),
+    loadedAt: text("loaded_at").notNull(),
+    lastSeenAt: text("last_seen_at").notNull(),
+}, (table) => [
+    primaryKey({ columns: [table.workspaceSessionId, table.path] }),
+    index("loaded_agent_files_path_idx").on(table.path),
+]);
+export const workspaceConversationBindings = sqliteTable("workspace_conversation_bindings", {
+    conversationScopeId: text("conversation_scope_id").notNull(),
+    targetKey: text("target_key").notNull(),
+    workspaceSessionId: text("workspace_session_id")
+        .notNull()
+        .references(() => workspaceSessions.id, { onDelete: "cascade" }),
+    createdAt: text("created_at").notNull(),
+    lastUsedAt: text("last_used_at").notNull(),
+}, (table) => [
+    primaryKey({ columns: [table.conversationScopeId, table.targetKey] }),
+    index("workspace_conversation_bindings_workspace_idx").on(table.workspaceSessionId),
+]);
+export const oauthClients = sqliteTable("oauth_clients", {
+    clientId: text("client_id").primaryKey(),
+    clientJson: text("client_json").notNull(),
+    issuedAt: integer("issued_at").notNull(),
+});
+export const oauthAccessTokens = sqliteTable("oauth_access_tokens", {
+    tokenHash: text("token_hash").primaryKey(),
+    clientId: text("client_id")
+        .notNull()
+        .references(() => oauthClients.clientId, { onDelete: "cascade" }),
+    scopesJson: text("scopes_json").notNull(),
+    expiresAt: integer("expires_at").notNull(),
+    resource: text("resource"),
+});
+export const oauthRefreshTokens = sqliteTable("oauth_refresh_tokens", {
+    tokenHash: text("token_hash").primaryKey(),
+    clientId: text("client_id")
+        .notNull()
+        .references(() => oauthClients.clientId, { onDelete: "cascade" }),
+    scopesJson: text("scopes_json").notNull(),
+    expiresAt: integer("expires_at").notNull(),
+    resource: text("resource"),
+});
+export const localAgentSessions = sqliteTable("local_agent_sessions", {
+    id: text("id").primaryKey(),
+    workspaceId: text("workspace_id"),
+    workspaceRoot: text("workspace_root").notNull(),
+    profileName: text("profile_name").notNull(),
+    provider: text("provider").notNull(),
+    model: text("model"),
+    thinking: text("thinking"),
+    providerSessionId: text("provider_session_id"),
+    status: text("status").notNull(),
+    latestResponse: text("latest_response"),
+    error: text("error"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+}, (table) => [
+    index("local_agent_sessions_workspace_id_idx").on(table.workspaceId, table.updatedAt),
+    index("local_agent_sessions_workspace_root_idx").on(table.workspaceRoot, table.updatedAt),
+    index("local_agent_sessions_provider_session_id_idx").on(table.providerSessionId),
+]);