@opencode-linear-agent/server 0.1.3-master.16 → 0.1.3-master.17

package/dist/index.js

@@ -80989,7 +80989,7 @@ function generateSuccessHtml(result) {
     
     <h2>Next Steps:</h2>
     <ul>
-      <li><strong>Optional:</strong> set <code>LINEAR_ORGANIZATION_ID</code> to restrict to one org:
+      <li><strong>Optional:</strong> set <code>linearOrganizationId</code> in <code>~/.config/opencode-linear-agent/config.json</code> to restrict to one org:
         <br><code>${result.organizationId}</code>
       </li>
       <li>Make sure your webhook URL is configured in Linear:
@@ -81338,88 +81338,91 @@ class OpencodeService {
 }
 // src/config.ts
 import { homedir } from "os";
-import { resolve, join as join2 } from "path";
+import path2, { resolve } from "path";
+
+// ../../node_modules/.bun/xdg-basedir@5.1.0/node_modules/xdg-basedir/index.js
+import os from "os";
+import path from "path";
+var homeDirectory = os.homedir();
+var { env } = process;
+var xdgData = env.XDG_DATA_HOME || (homeDirectory ? path.join(homeDirectory, ".local", "share") : undefined);
+var xdgConfig = env.XDG_CONFIG_HOME || (homeDirectory ? path.join(homeDirectory, ".config") : undefined);
+var xdgState = env.XDG_STATE_HOME || (homeDirectory ? path.join(homeDirectory, ".local", "state") : undefined);
+var xdgCache = env.XDG_CACHE_HOME || (homeDirectory ? path.join(homeDirectory, ".cache") : undefined);
+var xdgRuntime = env.XDG_RUNTIME_DIR || undefined;
+var xdgDataDirectories = (env.XDG_DATA_DIRS || "/usr/local/share/:/usr/share/").split(":");
+if (xdgData) {
+  xdgDataDirectories.unshift(xdgData);
+}
+var xdgConfigDirectories = (env.XDG_CONFIG_DIRS || "/etc/xdg").split(":");
+if (xdgConfig) {
+  xdgConfigDirectories.unshift(xdgConfig);
+}
+
+// src/config.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
 var DEFAULT_WEBHOOK_IPS = [
   "35.231.147.226",
   "35.243.134.228",
   "34.145.29.68"
 ];
-var ConfigSchema = exports_external.object({
-  port: exports_external.coerce.number(),
-  publicHostname: exports_external.string(),
-  opencode: exports_external.object({
-    url: exports_external.string()
-  }),
-  linear: exports_external.object({
-    clientId: exports_external.string(),
-    clientSecret: exports_external.string(),
-    webhookSecret: exports_external.string(),
-    organizationId: exports_external.string().optional(),
-    webhookIps: exports_external.array(exports_external.string()).min(1)
-  }),
-  projectsPath: exports_external.string()
+var ConfigFileSchema = exports_external.object({
+  webhookServerPublicHostname: exports_external.string().min(1),
+  webhookServerPort: exports_external.coerce.number().default(3210),
+  opencodeServerUrl: exports_external.string().min(1).default("http://localhost:4096"),
+  linearClientId: exports_external.string().min(1),
+  linearClientSecret: exports_external.string().min(1),
+  linearWebhookSecret: exports_external.string().min(1),
+  linearWebhookIps: exports_external.array(exports_external.string()).min(1).default(DEFAULT_WEBHOOK_IPS),
+  linearOrganizationId: exports_external.string().optional(),
+  projectsPath: exports_external.string().min(1).transform((projectsPath) => {
+    if (projectsPath.startsWith("~/")) {
+      return resolve(homedir(), projectsPath.slice(2));
+    }
+    return projectsPath;
+  })
 });
-function expandPath(path) {
-  if (path.startsWith("~/")) {
-    return resolve(homedir(), path.slice(2));
+var APPLICATION_DIRECTORY = "opencode-linear-agent";
+function loadConfig() {
+  if (!xdgConfig) {
+    throw new Error("Failed to find directory for config storage. Please ensure HOME or XDG_CONFIG_HOME environment variable is set.");
   }
-  return path;
-}
-function requiredEnv(name) {
-  const value = process.env[name];
-  if (!value) {
-    throw new Error(`Missing required environment variable: ${name}`);
+  const configPath = path2.join(xdgConfig, APPLICATION_DIRECTORY, "config.json");
+  if (!existsSync3(configPath)) {
+    throw new Error(`Config file not found at ${configPath}. Please create a config file with the necessary configuration values.`);
   }
-  return value;
-}
-function loadConfig() {
-  const log = Log.create({ service: "config" });
-  log.info("Loading config from environment variables");
-  const webhookIpsRaw = process.env["LINEAR_WEBHOOK_IPS"];
-  const webhookIps = webhookIpsRaw ? webhookIpsRaw.split(",").map((ip) => ip.trim()) : DEFAULT_WEBHOOK_IPS;
-  const raw = {
-    port: process.env["PORT"] ?? "3210",
-    publicHostname: requiredEnv("PUBLIC_HOSTNAME"),
-    opencode: {
-      url: process.env["OPENCODE_URL"] ?? "http://localhost:4096"
-    },
-    linear: {
-      clientId: requiredEnv("LINEAR_CLIENT_ID"),
-      clientSecret: requiredEnv("LINEAR_CLIENT_SECRET"),
-      webhookSecret: requiredEnv("LINEAR_WEBHOOK_SECRET"),
-      organizationId: process.env["LINEAR_ORGANIZATION_ID"],
-      webhookIps
-    },
-    projectsPath: requiredEnv("PROJECTS_PATH")
-  };
-  const result = ConfigSchema.safeParse(raw);
+  const rawConfig = readFileSync(configPath, "utf-8");
+  let raw;
+  try {
+    raw = JSON.parse(rawConfig);
+  } catch (err2) {
+    throw new Error(`Failed to parse config file at ${configPath}`, {
+      cause: err2
+    });
+  }
+  const result = ConfigFileSchema.safeParse(raw);
   if (!result.success) {
     const issues = result.error.issues.map((issue2) => `  - ${issue2.path.join(".")}: ${issue2.message}`).join(`
 `);
     throw new Error(`Invalid configuration:
 ${issues}`);
   }
-  return {
-    ...result.data,
-    projectsPath: expandPath(result.data.projectsPath)
-  };
-}
-function getWorkerUrl(config2) {
-  return `https://${config2.publicHostname}`;
-}
-function getDataDir() {
-  return join2(homedir(), ".local/share/opencode-linear-agent");
+  return result.data;
 }
 
 // src/storage/FileStore.ts
-import { mkdir } from "fs/promises";
-import { dirname } from "path";
+import { mkdir, writeFile, readFile, exists } from "fs/promises";
+import { dirname, join as join2 } from "path";
 class FileStore {
-  filePath;
   data = {};
   loaded = false;
-  constructor(filePath) {
-    this.filePath = filePath;
+  filePath;
+  constructor() {
+    if (!xdgData) {
+      throw new Error("Failed to find directory for data storage. Please ensure HOME or XDG_DATA_HOME environment variable is set.");
+    }
+    const dataDir = join2(xdgData, APPLICATION_DIRECTORY, "store.json");
+    this.filePath = dataDir;
   }
   async ensureLoaded() {
     if (this.loaded) {
@@ -81428,20 +81431,23 @@ class FileStore {
     await this.reload();
   }
   async reload() {
-    const file2 = Bun.file(this.filePath);
-    if (await file2.exists()) {
-      try {
-        const json2 = await file2.json();
-        this.data = parseStoreData(json2);
-      } catch {
-        this.data = {};
-      }
+    if (!await exists(this.filePath)) {
+      this.data = {};
+      this.loaded = true;
+      return;
+    }
+    const file2 = await readFile(this.filePath);
+    try {
+      const json2 = JSON.parse(file2.toString());
+      this.data = parseStoreData(json2);
+    } catch {
+      this.data = {};
     }
     this.loaded = true;
   }
   async save() {
     await mkdir(dirname(this.filePath), { recursive: true });
-    await Bun.write(this.filePath, JSON.stringify(this.data, null, 2));
+    await writeFile(this.filePath, JSON.stringify(this.data, null, 2));
   }
   isExpired(stored) {
     if (!stored.expires) {
@@ -81941,7 +81947,6 @@ async function dispatchAgentSessionEvent(event, linear2, opencode2, sessionRepos
 }
 
 // src/index.ts
-import { join as join4 } from "path";
 function getClientIp(request) {
   const cfIp = request.headers.get("cf-connecting-ip");
   if (cfIp) {
@@ -81962,7 +81967,7 @@ function isAllowedIp(ip, allowlist) {
 }
 function createDirectDispatcher(config2, tokenStore, sessionRepository) {
   const opencodeClient = createOpencodeClient({
-    baseUrl: config2.opencode.url
+    baseUrl: config2.opencodeServerUrl
   });
   const opencode2 = new OpencodeService(opencodeClient);
   return {
@@ -81972,8 +81977,8 @@ function createDirectDispatcher(config2, tokenStore, sessionRepository) {
         let accessToken2 = await tokenStore.getAccessToken(organizationId);
         if (!accessToken2) {
           const oauthConfig = {
-            clientId: config2.linear.clientId,
-            clientSecret: config2.linear.clientSecret
+            clientId: config2.linearClientId,
+            clientSecret: config2.linearClientSecret
           };
           accessToken2 = await refreshAccessToken(oauthConfig, tokenStore, organizationId);
         }
@@ -81987,8 +81992,8 @@ function createDirectDispatcher(config2, tokenStore, sessionRepository) {
       if (!accessToken) {
         Log.create({ service: "dispatcher" }).tag("organizationId", organizationId).info("No access token, attempting refresh");
         const oauthConfig = {
-          clientId: config2.linear.clientId,
-          clientSecret: config2.linear.clientSecret
+          clientId: config2.linearClientId,
+          clientSecret: config2.linearClientSecret
         };
         accessToken = await refreshAccessToken(oauthConfig, tokenStore, organizationId);
       }
@@ -82002,12 +82007,12 @@ function createDirectDispatcher(config2, tokenStore, sessionRepository) {
 }
 function createServer(config2, kv, tokenStore, dispatcher) {
   const oauthConfig = {
-    clientId: config2.linear.clientId,
-    clientSecret: config2.linear.clientSecret,
-    baseUrl: getWorkerUrl(config2)
+    clientId: config2.linearClientId,
+    clientSecret: config2.linearClientSecret,
+    baseUrl: `https://${config2.webhookServerPublicHostname}`
   };
   return Bun.serve({
-    port: config2.port,
+    port: config2.webhookServerPort,
     async fetch(request) {
       const url2 = new URL(request.url);
       const pathname = url2.pathname;
@@ -82022,24 +82027,24 @@ function createServer(config2, kv, tokenStore, dispatcher) {
         });
         return response;
       };
-      if (pathname === "/api/oauth/authorize") {
-        return respond(await handleAuthorize(request, oauthConfig, kv));
-      }
       if (pathname === "/health") {
         return respond(new Response("OK", { status: 200 }));
       }
+      if (pathname === "/api/oauth/authorize") {
+        return respond(await handleAuthorize(request, oauthConfig, kv));
+      }
       if (pathname === "/api/oauth/callback") {
         return respond(await handleCallback(request, oauthConfig, kv, tokenStore));
       }
-      if (pathname === "/api/webhook/linear" || pathname === "/webhook/linear") {
-        if (!isAllowedIp(clientIp, config2.linear.webhookIps)) {
+      if (pathname === "/api/webhook/linear") {
+        if (!isAllowedIp(clientIp, config2.linearWebhookIps)) {
           log.warn("Webhook request from unauthorized IP", {
             clientIp,
-            allowedIps: config2.linear.webhookIps
+            allowedIps: config2.linearWebhookIps
           });
           return respond(new Response("Forbidden", { status: 403 }));
         }
-        return respond(await handleWebhook(request, config2.linear.webhookSecret, tokenStore, dispatcher, undefined, config2.linear.organizationId));
+        return respond(await handleWebhook(request, config2.linearWebhookSecret, tokenStore, dispatcher, undefined, config2.linearOrganizationId));
       }
       return respond(new Response("Not found", { status: 404 }));
     }
@@ -82047,14 +82052,14 @@ function createServer(config2, kv, tokenStore, dispatcher) {
 }
 function startTokenRefreshTimer(config2, tokenStore) {
   const log = Log.create({ service: "token-refresh" });
-  const organizationId = config2.linear.organizationId;
+  const organizationId = config2.linearOrganizationId;
   if (!organizationId) {
     log.info("Skipping proactive token refresh (LINEAR_ORGANIZATION_ID not set)");
     return;
   }
   const oauthConfig = {
-    clientId: config2.linear.clientId,
-    clientSecret: config2.linear.clientSecret
+    clientId: config2.linearClientId,
+    clientSecret: config2.linearClientSecret
   };
   const REFRESH_INTERVAL_MS = 20 * 60 * 60 * 1000;
   const refresh = async () => {
@@ -82070,61 +82075,37 @@ function startTokenRefreshTimer(config2, tokenStore) {
   refresh();
   setInterval(() => void refresh(), REFRESH_INTERVAL_MS);
 }
-async function validateStoreFile(filePath, log) {
-  const file2 = Bun.file(filePath);
-  if (!await file2.exists()) {
-    return;
-  }
-  const result = await Result.tryPromise({
-    try: async () => {
-      const json2 = await file2.json();
-      parseStoreData(json2);
-    },
-    catch: (e) => e instanceof Error ? e.message : String(e)
-  });
-  if (Result.isError(result)) {
-    log.warn("Invalid shared store file detected", {
-      dataPath: filePath,
-      error: result.error,
-      recovery: "Fix/restore store.json, restart server, then re-auth Linear if token data was lost."
-    });
-  }
-}
 async function main() {
   const log = Log.create({ service: "startup" });
   log.info("Starting Linear OpenCode Agent (Local)");
   const config2 = loadConfig();
   log.info("Configuration loaded", {
-    port: config2.port,
-    publicHostname: config2.publicHostname,
-    opencodeUrl: config2.opencode.url,
+    port: config2.webhookServerPort,
+    publicHostname: config2.webhookServerPublicHostname,
+    opencodeUrl: config2.opencodeServerUrl,
     projectsPath: config2.projectsPath
   });
-  const dataDir = getDataDir();
-  const dataPath = join4(dataDir, "store.json");
-  const kv = new FileStore(dataPath);
+  const kv = new FileStore;
   const tokenStore = new FileTokenStore(kv);
   const sessionRepository = new FileSessionRepository(kv);
-  log.info("Storage initialized", { dataPath });
-  await validateStoreFile(dataPath, log);
   startTokenRefreshTimer(config2, tokenStore);
   const dispatcher = createDirectDispatcher(config2, tokenStore, sessionRepository);
   const server2 = createServer(config2, kv, tokenStore, dispatcher);
-  const workerUrl = getWorkerUrl(config2);
+  const webhookServerUrl = `https://${config2.webhookServerPublicHostname}`;
   log.info("Server started", {
-    port: config2.port,
-    workerUrl,
-    webhookUrl: `${workerUrl}/api/webhook/linear`,
-    oauthUrl: `${workerUrl}/api/oauth/authorize`
+    port: config2.webhookServerPort,
+    webhookServerUrl,
+    webhookUrl: `${webhookServerUrl}/api/webhook/linear`,
+    oauthUrl: `${webhookServerUrl}/api/oauth/authorize`
   });
   process.stdout.write(`
 Linear OpenCode Agent (Local) running!
 
-  Local:    http://localhost:${config2.port}
-  Public:   ${workerUrl}
+  Local:    http://localhost:${config2.webhookServerPort}
+  Public:   ${webhookServerUrl}
 
-  Webhook URL: ${workerUrl}/api/webhook/linear
-  OAuth URL:   ${workerUrl}/api/oauth/authorize
+  Webhook URL: ${webhookServerUrl}/api/webhook/linear
+  OAuth URL:   ${webhookServerUrl}/api/oauth/authorize
 
 Make sure OpenCode is running: opencode serve
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-linear-agent/server",
-  "version": "0.1.3-master.16",
+  "version": "0.1.3-master.17",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -33,6 +33,7 @@
     "@linear/sdk": "catalog:",
     "@opencode-ai/sdk": "catalog:",
     "better-result": "catalog:",
+    "xdg-basedir": "catalog:",
     "zod": "catalog:"
   },
   "peerDependencies": {