@schuttdev/kon 0.3.3 → 0.3.5

package/dist/index.js

@@ -234,27 +234,37 @@ async function ensureDispatcher() {
   }
   return _dispatcher;
 }
-function createHttpClient(serverUrl, sessionToken) {
+function createHttpClient(serverUrl, sessionToken, onAuthFailure) {
   const baseUrl = serverUrl.replace(/\/$/, "");
+  let currentToken = sessionToken;
+  async function rawFetch(url, init) {
+    const dispatcher = await ensureDispatcher();
+    const fetchOpts = { ...init };
+    if (dispatcher) fetchOpts.dispatcher = dispatcher;
+    return fetch(url, fetchOpts);
+  }
+  function authHeaders() {
+    const h = {};
+    if (currentToken) h["Authorization"] = `Bearer ${currentToken}`;
+    return h;
+  }
   async function request(path, init = {}) {
     const headers = {
-      ...init.headers ?? {}
+      ...init.headers ?? {},
+      ...authHeaders()
     };
-    if (sessionToken) {
-      headers["Authorization"] = `Bearer ${sessionToken}`;
-    }
     if (!headers["Content-Type"] && init.body && typeof init.body === "string") {
       headers["Content-Type"] = "application/json";
     }
-    const dispatcher = await ensureDispatcher();
-    const fetchOpts = {
-      ...init,
-      headers
-    };
-    if (dispatcher) {
-      fetchOpts.dispatcher = dispatcher;
+    let res = await rawFetch(`${baseUrl}${path}`, { ...init, headers });
+    if (res.status === 401 && onAuthFailure) {
+      const newToken = await onAuthFailure();
+      if (newToken) {
+        currentToken = newToken;
+        headers["Authorization"] = `Bearer ${newToken}`;
+        res = await rawFetch(`${baseUrl}${path}`, { ...init, headers });
+      }
     }
-    const res = await fetch(`${baseUrl}${path}`, fetchOpts);
     if (!res.ok) {
       let errorBody;
       try {
@@ -277,16 +287,20 @@ function createHttpClient(serverUrl, sessionToken) {
       });
     },
     async delete(path) {
-      const headers = {};
-      if (sessionToken) {
-        headers["Authorization"] = `Bearer ${sessionToken}`;
-      }
-      const dispatcher = await ensureDispatcher();
-      const fetchOpts = { method: "DELETE", headers };
-      if (dispatcher) {
-        fetchOpts.dispatcher = dispatcher;
+      let res = await rawFetch(`${baseUrl}${path}`, {
+        method: "DELETE",
+        headers: authHeaders()
+      });
+      if (res.status === 401 && onAuthFailure) {
+        const newToken = await onAuthFailure();
+        if (newToken) {
+          currentToken = newToken;
+          res = await rawFetch(`${baseUrl}${path}`, {
+            method: "DELETE",
+            headers: authHeaders()
+          });
+        }
       }
-      const res = await fetch(`${baseUrl}${path}`, fetchOpts);
       if (!res.ok) {
         let errorBody;
         try {
@@ -297,20 +311,22 @@ function createHttpClient(serverUrl, sessionToken) {
       }
     },
     async postMultipart(path, formData) {
-      const headers = {};
-      if (sessionToken) {
-        headers["Authorization"] = `Bearer ${sessionToken}`;
-      }
-      const dispatcher = await ensureDispatcher();
-      const fetchOpts = {
+      let res = await rawFetch(`${baseUrl}${path}`, {
         method: "POST",
-        headers,
+        headers: authHeaders(),
         body: formData
-      };
-      if (dispatcher) {
-        fetchOpts.dispatcher = dispatcher;
+      });
+      if (res.status === 401 && onAuthFailure) {
+        const newToken = await onAuthFailure();
+        if (newToken) {
+          currentToken = newToken;
+          res = await rawFetch(`${baseUrl}${path}`, {
+            method: "POST",
+            headers: authHeaders(),
+            body: formData
+          });
+        }
       }
-      const res = await fetch(`${baseUrl}${path}`, fetchOpts);
       if (!res.ok) {
         let errorBody;
         try {
@@ -322,16 +338,18 @@ function createHttpClient(serverUrl, sessionToken) {
       return res.json();
     },
     async getRaw(path) {
-      const headers = {};
-      if (sessionToken) {
-        headers["Authorization"] = `Bearer ${sessionToken}`;
-      }
-      const dispatcher = await ensureDispatcher();
-      const fetchOpts = { headers };
-      if (dispatcher) {
-        fetchOpts.dispatcher = dispatcher;
+      let res = await rawFetch(`${baseUrl}${path}`, {
+        headers: authHeaders()
+      });
+      if (res.status === 401 && onAuthFailure) {
+        const newToken = await onAuthFailure();
+        if (newToken) {
+          currentToken = newToken;
+          res = await rawFetch(`${baseUrl}${path}`, {
+            headers: authHeaders()
+          });
+        }
       }
-      const res = await fetch(`${baseUrl}${path}`, fetchOpts);
       if (!res.ok) {
         throw new Error(`HTTP ${res.status}: ${res.statusText}`);
       }
@@ -341,7 +359,7 @@ function createHttpClient(serverUrl, sessionToken) {
 }
 
 // ../cli/src/version.ts
-var VERSION = "0.3.3";
+var VERSION = "0.3.5";
 
 // ../cli/src/connect.ts
 async function connect(serverName) {
@@ -361,15 +379,26 @@ async function connect(serverName) {
     throw new Error("No server configured. Run 'gigai pair' first.");
   }
   const { name, entry } = active;
+  const onAuthFailure = async () => {
+    try {
+      const result2 = await doRefreshSession(name, entry.server, entry.token);
+      return result2.sessionToken;
+    } catch {
+      return void 0;
+    }
+  };
   if (entry.sessionToken && entry.sessionExpiresAt) {
     if (Date.now() < entry.sessionExpiresAt - 5 * 60 * 1e3) {
-      await checkAndUpdateServer(entry.server, entry.sessionToken);
-      return { serverUrl: entry.server, sessionToken: entry.sessionToken };
+      const token = await checkAndUpdateServer(entry.server, entry.sessionToken, name, entry.token);
+      const http2 = createHttpClient(entry.server, token, onAuthFailure);
+      return { serverUrl: entry.server, sessionToken: token, http: http2 };
     }
   }
-  return refreshSession(name, entry.server, entry.token);
+  const result = await doRefreshSession(name, entry.server, entry.token);
+  const http = createHttpClient(entry.server, result.sessionToken, onAuthFailure);
+  return { serverUrl: entry.server, sessionToken: result.sessionToken, http };
 }
-async function refreshSession(serverName, serverUrl, encryptedToken) {
+async function doRefreshSession(serverName, serverUrl, encryptedToken) {
   const orgUuid = getOrgUUID();
   const http = createHttpClient(serverUrl);
   const res = await http.post("/auth/connect", {
@@ -377,10 +406,10 @@ async function refreshSession(serverName, serverUrl, encryptedToken) {
     orgUuid
   });
   await updateServerSession(serverName, res.sessionToken, res.expiresAt);
-  await checkAndUpdateServer(serverUrl, res.sessionToken);
-  return { serverUrl, sessionToken: res.sessionToken };
+  const token = await checkAndUpdateServer(serverUrl, res.sessionToken, serverName, encryptedToken);
+  return { serverUrl, sessionToken: token };
 }
-async function checkAndUpdateServer(serverUrl, sessionToken) {
+async function checkAndUpdateServer(serverUrl, sessionToken, serverName, encryptedToken) {
   try {
     const http = createHttpClient(serverUrl);
     const health = await http.get("/health");
@@ -403,12 +432,23 @@ async function checkAndUpdateServer(serverUrl, sessionToken) {
         console.log("Server updated and restarting.");
         await waitForServer(serverUrl, 15e3);
         console.log("Server is back online.");
+        if (serverName && encryptedToken) {
+          const orgUuid = getOrgUUID();
+          const unauthHttp = createHttpClient(serverUrl);
+          const connectRes = await unauthHttp.post("/auth/connect", {
+            encryptedToken,
+            orgUuid
+          });
+          await updateServerSession(serverName, connectRes.sessionToken, connectRes.expiresAt);
+          return connectRes.sessionToken;
+        }
       } else {
         console.log(`Server update failed: ${res.error ?? "unknown error"}`);
       }
     }
   } catch {
   }
+  return sessionToken;
 }
 async function waitForServer(serverUrl, timeoutMs) {
   const start = Date.now();
@@ -1018,43 +1058,21 @@ if (firstArg && !firstArg.startsWith("-") && !KNOWN_COMMANDS.has(firstArg)) {
   const toolName = firstArg;
   const toolArgs = process.argv.slice(3);
   try {
-    let { serverUrl, sessionToken } = await connect();
-    let http = createHttpClient(serverUrl, sessionToken);
-    const runTool = async () => {
-      const { tool: detail } = await fetchToolDetail(http, toolName);
-      if (detail.type === "mcp") {
-        const mcpToolName = toolArgs[0];
-        if (!mcpToolName) {
-          const toolNames = (detail.mcpTools ?? []).map((t) => `  ${t.name} \u2014 ${t.description}`);
-          console.log(`MCP tools for ${toolName}:
+    const { http } = await connect();
+    const { tool: detail } = await fetchToolDetail(http, toolName);
+    if (detail.type === "mcp") {
+      const mcpToolName = toolArgs[0];
+      if (!mcpToolName) {
+        const toolNames = (detail.mcpTools ?? []).map((t) => `  ${t.name} \u2014 ${t.description}`);
+        console.log(`MCP tools for ${toolName}:
 ${toolNames.join("\n")}`);
-        } else {
-          const jsonArg = toolArgs.slice(1).join(" ");
-          const args = jsonArg ? JSON.parse(jsonArg) : {};
-          await execMcpTool(http, toolName, mcpToolName, args);
-        }
-      } else {
-        await execTool(http, toolName, toolArgs);
-      }
-    };
-    try {
-      await runTool();
-    } catch (e) {
-      const msg = e.message;
-      if (msg.includes("Invalid session") || msg.includes("Session expired") || msg.includes("Authorization")) {
-        const config = await readConfig();
-        const active = getActiveEntry(config);
-        if (active) {
-          const refreshed = await refreshSession(active.name, active.entry.server, active.entry.token);
-          sessionToken = refreshed.sessionToken;
-          http = createHttpClient(serverUrl, sessionToken);
-          await runTool();
-        } else {
-          throw e;
-        }
       } else {
-        throw e;
+        const jsonArg = toolArgs.slice(1).join(" ");
+        const args = jsonArg ? JSON.parse(jsonArg) : {};
+        await execMcpTool(http, toolName, mcpToolName, args);
       }
+    } else {
+      await execTool(http, toolName, toolArgs);
     }
   } catch (e) {
     console.error(`Error: ${e.message}`);
@@ -1087,8 +1105,7 @@ function runCitty() {
   const listCommand = defineCommand({
     meta: { name: "list", description: "List available tools" },
     async run() {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
+      const { http } = await connect();
       const tools = await fetchTools(http);
       console.log(formatToolList(tools));
     }
@@ -1099,8 +1116,7 @@ function runCitty() {
       tool: { type: "positional", description: "Tool name", required: true }
     },
     async run({ args }) {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
+      const { http } = await connect();
       const { tool } = await fetchToolDetail(http, args.tool);
       console.log(formatToolDetail(tool));
     }
@@ -1118,8 +1134,7 @@ function runCitty() {
       file: { type: "positional", description: "File path", required: true }
     },
     async run({ args }) {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
+      const { http } = await connect();
       await upload(http, args.file);
     }
   });
@@ -1130,8 +1145,7 @@ function runCitty() {
       dest: { type: "positional", description: "Destination path", required: true }
     },
     async run({ args }) {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
+      const { http } = await connect();
       await download(http, args.id, args.dest);
     }
   });
@@ -1144,8 +1158,7 @@ function runCitty() {
   const skillCommand = defineCommand({
     meta: { name: "skill", description: "Regenerate the skill zip with current tool details" },
     async run() {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
+      const { http } = await connect();
       const tools = await fetchTools(http);
       console.log(`Fetching details for ${tools.length} tool(s)...`);
       const toolDetails = await Promise.all(
@@ -1174,8 +1187,7 @@ Skill zip written to: ${outPath}`);
       at: { type: "string", description: "Human-readable time (e.g. '9:00 AM tomorrow')" }
     },
     async run({ args }) {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
+      const { http } = await connect();
       const rawArgs = process.argv.slice(4);
       const positional = [];
       let atValue = args.at;
@@ -1232,8 +1244,7 @@ Skill zip written to: ${outPath}`);
   const cronListCommand = defineCommand({
     meta: { name: "list", description: "List scheduled jobs" },
     async run() {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
+      const { http } = await connect();
       const res = await http.get("/cron");
       if (res.jobs.length === 0) {
         console.log("No scheduled jobs.");
@@ -1257,8 +1268,7 @@ Skill zip written to: ${outPath}`);
       id: { type: "positional", description: "Job ID", required: true }
     },
     async run({ args }) {
-      const { serverUrl, sessionToken } = await connect();
-      const http = createHttpClient(serverUrl, sessionToken);
+      const { http } = await connect();
       await http.delete(`/cron/${encodeURIComponent(args.id)}`);
       console.log(`Removed: ${args.id}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schuttdev/kon",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "type": "module",
   "license": "MIT",
   "description": "Lightweight gigai client for Claude code execution",