@schuttdev/kon 0.3.2 → 0.3.4

package/dist/index.js

@@ -341,7 +341,7 @@ function createHttpClient(serverUrl, sessionToken) {
 }
 
 // ../cli/src/version.ts
-var VERSION = "0.3.2";
+var VERSION = "0.3.4";
 
 // ../cli/src/connect.ts
 async function connect(serverName) {
@@ -363,21 +363,24 @@ async function connect(serverName) {
   const { name, entry } = active;
   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);
+      return { serverUrl: entry.server, sessionToken: token };
     }
   }
+  return refreshSession(name, entry.server, entry.token);
+}
+async function refreshSession(serverName, serverUrl, encryptedToken) {
   const orgUuid = getOrgUUID();
-  const http = createHttpClient(entry.server);
+  const http = createHttpClient(serverUrl);
   const res = await http.post("/auth/connect", {
-    encryptedToken: entry.token,
+    encryptedToken,
     orgUuid
   });
-  await updateServerSession(name, res.sessionToken, res.expiresAt);
-  await checkAndUpdateServer(entry.server, res.sessionToken);
-  return { serverUrl: entry.server, sessionToken: res.sessionToken };
+  await updateServerSession(serverName, res.sessionToken, res.expiresAt);
+  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");
@@ -400,12 +403,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();
@@ -1015,22 +1029,43 @@ if (firstArg && !firstArg.startsWith("-") && !KNOWN_COMMANDS.has(firstArg)) {
   const toolName = firstArg;
   const toolArgs = process.argv.slice(3);
   try {
-    const { serverUrl, sessionToken } = await connect();
-    const http = createHttpClient(serverUrl, sessionToken);
-    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}:
+    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}:
 ${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 {
-        const jsonArg = toolArgs.slice(1).join(" ");
-        const args = jsonArg ? JSON.parse(jsonArg) : {};
-        await execMcpTool(http, toolName, mcpToolName, args);
+        throw e;
       }
-    } else {
-      await execTool(http, toolName, toolArgs);
     }
   } catch (e) {
     console.error(`Error: ${e.message}`);

package/package.json

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