@schuttdev/kon 0.2.9 → 0.3.1

package/dist/index.js

@@ -276,6 +276,26 @@ function createHttpClient(serverUrl, sessionToken) {
         body: body ? JSON.stringify(body) : void 0
       });
     },
+    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;
+      }
+      const res = await fetch(`${baseUrl}${path}`, fetchOpts);
+      if (!res.ok) {
+        let errorBody;
+        try {
+          errorBody = await res.json();
+        } catch {
+        }
+        throw new Error(errorBody?.error?.message ?? `HTTP ${res.status}`);
+      }
+    },
     async postMultipart(path, formData) {
       const headers = {};
       if (sessionToken) {
@@ -321,7 +341,7 @@ function createHttpClient(serverUrl, sessionToken) {
 }
 
 // ../cli/src/version.ts
-var VERSION = "0.2.9";
+var VERSION = "0.3.1";
 
 // ../cli/src/connect.ts
 async function connect(serverName) {
@@ -361,6 +381,17 @@ async function checkAndUpdateServer(serverUrl, sessionToken) {
   try {
     const http = createHttpClient(serverUrl);
     const health = await http.get("/health");
+    if (health.platform || health.hostname) {
+      const config = await readConfig();
+      for (const entry of Object.values(config.servers)) {
+        if (normalizeUrl2(entry.server) === normalizeUrl2(serverUrl)) {
+          entry.platform = health.platform;
+          entry.hostname = health.hostname;
+          break;
+        }
+      }
+      await writeConfig(config);
+    }
     if (isNewer(VERSION, health.version)) {
       console.log(`Server is outdated (${health.version} \u2192 ${VERSION}). Updating...`);
       const authedHttp = createHttpClient(serverUrl, sessionToken);
@@ -389,6 +420,13 @@ async function waitForServer(serverUrl, timeoutMs) {
     }
   }
 }
+function normalizeUrl2(url) {
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
+}
 function isNewer(client, server) {
   const parse = (v) => {
     const [core, pre] = v.replace(/^v/, "").split("-");
@@ -407,8 +445,40 @@ function isNewer(client, server) {
   return false;
 }
 
-// ../cli/src/skill.ts
+// ../cli/src/discover.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var MANIFEST_TTL = 5 * 60 * 1e3;
+function getManifestPath() {
+  const dir = process.env.GIGAI_CONFIG_DIR ?? join2(homedir2(), ".gigai");
+  return join2(dir, "tool-manifest.json");
+}
+async function fetchTools(http) {
+  try {
+    const raw = await readFile2(getManifestPath(), "utf8");
+    const cache = JSON.parse(raw);
+    if (Date.now() - cache.fetchedAt < MANIFEST_TTL) {
+      return cache.tools;
+    }
+  } catch {
+  }
+  const res = await http.get("/tools");
+  try {
+    const dir = process.env.GIGAI_CONFIG_DIR ?? join2(homedir2(), ".gigai");
+    await mkdir2(dir, { recursive: true });
+    const cache = { tools: res.tools, fetchedAt: Date.now() };
+    await writeFile2(getManifestPath(), JSON.stringify(cache));
+  } catch {
+  }
+  return res.tools;
+}
+async function fetchToolDetail(http, name) {
+  return http.get(`/tools/${encodeURIComponent(name)}`);
+}
+
+// ../cli/src/skill.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
 import "path";
 var SKILL_MD = `---
 name: gigai
@@ -505,32 +575,151 @@ For MCP tools, the first arg is the MCP tool name:
 kon <mcp-tool> <mcp-action> [json-args]
 \`\`\`
 
+## Scheduling tasks
+
+Schedule any tool execution on the server:
+\`\`\`bash
+kon cron add "0 9 * * *" bash git pull              # daily at 9am
+kon cron add --at "9:00 AM tomorrow" bash git pull   # one-shot
+kon cron add --at "in 30 minutes" read ~/log.txt     # relative time
+kon cron list                                        # list scheduled jobs
+kon cron remove <id>                                 # remove a job
+\`\`\`
+
 ## Multiple servers
 
+The user may have multiple servers configured (e.g. a Mac and a Linux machine). Use \`kon status\` to see all servers and which is active.
+
 \`\`\`bash
-kon connect <server-name>
-kon status
+kon status                    # show all servers + active
+kon connect <server-name>     # switch to a different server
+kon list                      # list tools on the current server
 \`\`\`
 
+**Routing between servers:** When a tool is not available on the current server, or when a task requires a specific platform (e.g. iMessage requires macOS), switch to the appropriate server:
+
+1. Run \`kon status\` to see available servers
+2. Run \`kon connect <server-name>\` to switch
+3. Run \`kon list\` to verify the tool is available
+4. Execute the command
+
+Platform-specific capabilities:
+- **iMessage**: only available on macOS servers
+- **macOS apps** (Shortcuts, AppleScript): only on macOS servers
+- **systemd, apt, etc.**: only on Linux servers
+
+The \`kon list\` response includes the server's platform. Use this to determine which server to route a request to.
+
 ## Important
 
 - Always run the setup block before first use in a new conversation
 - All commands execute on the **user's machine**, not in this sandbox
 - If you get auth errors, run \`kon connect\` to refresh the session
 - Tools are scoped to what the user has configured \u2014 if a tool is missing, tell the user
+- If you have multiple servers, check which server has the tool you need before executing
 `;
 async function hasExistingSkill() {
   try {
-    await readFile2("/mnt/skills/user/gigai/config.json", "utf8");
+    await readFile3("/mnt/skills/user/gigai/config.json", "utf8");
     return true;
   } catch {
     return false;
   }
 }
-async function generateSkillZip(serverName, serverUrl, token) {
+function generateToolMarkdown(tool) {
+  const lines = [];
+  lines.push("---");
+  lines.push(`name: ${tool.name}`);
+  lines.push(`description: ${tool.description}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${tool.name}`);
+  lines.push("");
+  lines.push(`**Type:** ${tool.type}`);
+  lines.push("");
+  lines.push(tool.description);
+  lines.push("");
+  lines.push("## Usage");
+  lines.push("");
+  if (tool.type === "builtin") {
+    switch (tool.name) {
+      case "read":
+        lines.push("```bash");
+        lines.push("kon read <file> [offset] [limit]");
+        lines.push("```");
+        break;
+      case "write":
+        lines.push("```bash");
+        lines.push("kon write <file> <content>");
+        lines.push("```");
+        break;
+      case "edit":
+        lines.push("```bash");
+        lines.push("kon edit <file> <old_string> <new_string> [--all]");
+        lines.push("```");
+        break;
+      case "glob":
+        lines.push("```bash");
+        lines.push("kon glob <pattern> [path]");
+        lines.push("```");
+        break;
+      case "grep":
+        lines.push("```bash");
+        lines.push("kon grep <pattern> [path] [--glob <filter>] [-i] [-n] [-C <num>]");
+        lines.push("```");
+        break;
+      case "bash":
+        lines.push("```bash");
+        lines.push("kon bash <command> [args...]");
+        lines.push("```");
+        break;
+      default:
+        lines.push("```bash");
+        lines.push(`kon ${tool.name} [args...]`);
+        lines.push("```");
+    }
+  } else if (tool.type === "mcp") {
+    lines.push("```bash");
+    lines.push(`kon ${tool.name} <mcp-tool-name> [json-args]`);
+    lines.push("```");
+  } else {
+    lines.push("```bash");
+    lines.push(`kon ${tool.name} [args...]`);
+    lines.push("```");
+  }
+  lines.push("");
+  if (tool.args && tool.args.length > 0) {
+    lines.push("## Arguments");
+    lines.push("");
+    for (const arg of tool.args) {
+      const req = arg.required ? " *(required)*" : "";
+      const def = arg.default ? ` (default: \`${arg.default}\`)` : "";
+      lines.push(`- \`${arg.name}\`${req}: ${arg.description}${def}`);
+    }
+    lines.push("");
+  }
+  if (tool.type === "mcp" && tool.mcpTools && tool.mcpTools.length > 0) {
+    lines.push("## Available MCP Tools");
+    lines.push("");
+    for (const mcpTool of tool.mcpTools) {
+      lines.push(`### ${mcpTool.name}`);
+      lines.push("");
+      lines.push(mcpTool.description);
+      lines.push("");
+      lines.push("**Input Schema:**");
+      lines.push("");
+      lines.push("```json");
+      lines.push(JSON.stringify(mcpTool.inputSchema, null, 2));
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+async function generateSkillZip(serverName, serverUrl, token, tools) {
   let skillConfig = { servers: {} };
   try {
-    const raw = await readFile2("/mnt/skills/user/gigai/config.json", "utf8");
+    const raw = await readFile3("/mnt/skills/user/gigai/config.json", "utf8");
     const existing = JSON.parse(raw);
     if (existing.servers) {
       skillConfig = existing;
@@ -551,21 +740,31 @@ async function generateSkillZip(serverName, serverUrl, token) {
     skillConfig.activeServer = serverName;
   }
   const configJson = JSON.stringify(skillConfig, null, 2) + "\n";
-  return createZip([
+  const entries = [
     { path: "gigai/SKILL.md", data: Buffer.from(SKILL_MD, "utf8") },
     { path: "gigai/config.json", data: Buffer.from(configJson, "utf8") }
-  ]);
+  ];
+  if (tools && tools.length > 0) {
+    for (const tool of tools) {
+      const md = generateToolMarkdown(tool);
+      entries.push({
+        path: `gigai/tools/${tool.name}.md`,
+        data: Buffer.from(md, "utf8")
+      });
+    }
+  }
+  return createZip(entries);
 }
 async function writeSkillZip(zip) {
   const outputsDir = "/mnt/user-data/outputs";
   try {
-    await mkdir2(outputsDir, { recursive: true });
+    await mkdir3(outputsDir, { recursive: true });
     const outPath = `${outputsDir}/gigai.zip`;
-    await writeFile2(outPath, zip);
+    await writeFile3(outPath, zip);
     return outPath;
   } catch {
     const outPath = "gigai.zip";
-    await writeFile2(outPath, zip);
+    await writeFile3(outPath, zip);
     return outPath;
   }
 }
@@ -655,8 +854,21 @@ async function pair(code, serverUrl) {
   });
   await addServer(res.serverName, serverUrl, res.encryptedToken);
   console.log(`Paired with "${res.serverName}" successfully!`);
+  let toolDetails;
+  try {
+    const session = await connect();
+    const authedHttp = createHttpClient(session.serverUrl, session.sessionToken);
+    const tools = await fetchTools(authedHttp);
+    toolDetails = await Promise.all(
+      tools.map(async (t) => {
+        const { tool } = await fetchToolDetail(authedHttp, t.name);
+        return tool;
+      })
+    );
+  } catch {
+  }
   const existing = await hasExistingSkill();
-  const zip = await generateSkillZip(res.serverName, serverUrl, res.encryptedToken);
+  const zip = await generateSkillZip(res.serverName, serverUrl, res.encryptedToken, toolDetails);
   const outPath = await writeSkillZip(zip);
   console.log(`
 Skill zip written to: ${outPath}`);
@@ -667,38 +879,6 @@ Skill zip written to: ${outPath}`);
   }
 }
 
-// ../cli/src/discover.ts
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
-var MANIFEST_TTL = 5 * 60 * 1e3;
-function getManifestPath() {
-  const dir = process.env.GIGAI_CONFIG_DIR ?? join2(homedir2(), ".gigai");
-  return join2(dir, "tool-manifest.json");
-}
-async function fetchTools(http) {
-  try {
-    const raw = await readFile3(getManifestPath(), "utf8");
-    const cache = JSON.parse(raw);
-    if (Date.now() - cache.fetchedAt < MANIFEST_TTL) {
-      return cache.tools;
-    }
-  } catch {
-  }
-  const res = await http.get("/tools");
-  try {
-    const dir = process.env.GIGAI_CONFIG_DIR ?? join2(homedir2(), ".gigai");
-    await mkdir3(dir, { recursive: true });
-    const cache = { tools: res.tools, fetchedAt: Date.now() };
-    await writeFile3(getManifestPath(), JSON.stringify(cache));
-  } catch {
-  }
-  return res.tools;
-}
-async function fetchToolDetail(http, name) {
-  return http.get(`/tools/${encodeURIComponent(name)}`);
-}
-
 // ../cli/src/exec.ts
 async function execTool(http, name, args, timeout) {
   const res = await http.post("/exec", {
@@ -800,7 +980,8 @@ function formatStatus(config) {
   for (const name of serverNames) {
     const entry = config.servers[name];
     const active = name === config.activeServer ? " (active)" : "";
-    lines.push(`  ${name}${active}  ${entry.server}`);
+    const platformTag = entry.platform ? ` [${entry.platform}]` : "";
+    lines.push(`  ${name}${active}${platformTag}  ${entry.server}`);
     if (entry.sessionExpiresAt) {
       const remaining = entry.sessionExpiresAt - Date.now();
       if (remaining > 0) {
@@ -824,6 +1005,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "upload",
   "download",
   "version",
+  "skill",
+  "cron",
   "--help",
   "-h"
 ]);
@@ -934,6 +1117,136 @@ function runCitty() {
       console.log(`kon v${VERSION}`);
     }
   });
+  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 tools = await fetchTools(http);
+      console.log(`Fetching details for ${tools.length} tool(s)...`);
+      const toolDetails = await Promise.all(
+        tools.map(async (t) => {
+          const { tool } = await fetchToolDetail(http, t.name);
+          return tool;
+        })
+      );
+      const config = await readConfig();
+      const activeServer = config.activeServer;
+      if (!activeServer || !config.servers[activeServer]) {
+        throw new Error("No active server. Run 'kon connect' first.");
+      }
+      const entry = config.servers[activeServer];
+      const zip = await generateSkillZip(activeServer, entry.server, entry.token, toolDetails);
+      const outPath = await writeSkillZip(zip);
+      console.log(`
+Skill zip written to: ${outPath}`);
+      console.log(`Included ${toolDetails.length} tool documentation file(s).`);
+      console.log("Upload this file as a skill in Claude (Settings \u2192 Customize \u2192 Upload Skill).");
+    }
+  });
+  const cronAddCommand = defineCommand({
+    meta: { name: "add", description: "Schedule a tool execution" },
+    args: {
+      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 rawArgs = process.argv.slice(4);
+      const positional = [];
+      let atValue = args.at;
+      for (let i = 0; i < rawArgs.length; i++) {
+        if (rawArgs[i] === "--at" && rawArgs[i + 1]) {
+          atValue = rawArgs[i + 1];
+          i++;
+        } else if (!rawArgs[i].startsWith("--")) {
+          positional.push(rawArgs[i]);
+        }
+      }
+      let schedule;
+      let tool;
+      let toolArgs;
+      let oneShot = false;
+      if (atValue) {
+        tool = positional[0];
+        toolArgs = positional.slice(1);
+        const res2 = await http.post("/cron", {
+          schedule: `@at ${atValue}`,
+          tool,
+          args: toolArgs,
+          oneShot: true
+        });
+        console.log(`Scheduled: ${res2.job.id}`);
+        console.log(`  ${tool} ${toolArgs.join(" ")}`);
+        if (res2.job.nextRun) {
+          console.log(`  Next run: ${new Date(res2.job.nextRun).toLocaleString()}`);
+        }
+        return;
+      }
+      schedule = positional[0];
+      tool = positional[1];
+      toolArgs = positional.slice(2);
+      if (!schedule || !tool) {
+        console.error("Usage:");
+        console.error('  kon cron add "0 9 * * *" <tool> [args...]');
+        console.error('  kon cron add --at "9:00 AM tomorrow" <tool> [args...]');
+        process.exitCode = 1;
+        return;
+      }
+      const res = await http.post("/cron", {
+        schedule,
+        tool,
+        args: toolArgs
+      });
+      console.log(`Scheduled: ${res.job.id}`);
+      console.log(`  ${schedule} \u2014 ${tool} ${toolArgs.join(" ")}`);
+      if (res.job.nextRun) {
+        console.log(`  Next run: ${new Date(res.job.nextRun).toLocaleString()}`);
+      }
+    }
+  });
+  const cronListCommand = defineCommand({
+    meta: { name: "list", description: "List scheduled jobs" },
+    async run() {
+      const { serverUrl, sessionToken } = await connect();
+      const http = createHttpClient(serverUrl, sessionToken);
+      const res = await http.get("/cron");
+      if (res.jobs.length === 0) {
+        console.log("No scheduled jobs.");
+        return;
+      }
+      for (const job of res.jobs) {
+        const status = job.enabled ? "active" : "disabled";
+        const cmd = `${job.tool} ${job.args.join(" ")}`.trim();
+        const next = job.nextRun ? new Date(job.nextRun).toLocaleString() : "\u2014";
+        const last = job.lastRun ? new Date(job.lastRun).toLocaleString() : "never";
+        console.log(`${job.id}  [${status}]  ${job.schedule}`);
+        console.log(`  ${cmd}`);
+        console.log(`  next: ${next}  last: ${last}`);
+        console.log();
+      }
+    }
+  });
+  const cronRemoveCommand = defineCommand({
+    meta: { name: "remove", description: "Remove a scheduled job" },
+    args: {
+      id: { type: "positional", description: "Job ID", required: true }
+    },
+    async run({ args }) {
+      const { serverUrl, sessionToken } = await connect();
+      const http = createHttpClient(serverUrl, sessionToken);
+      await http.delete(`/cron/${encodeURIComponent(args.id)}`);
+      console.log(`Removed: ${args.id}`);
+    }
+  });
+  const cronCommand = defineCommand({
+    meta: { name: "cron", description: "Manage scheduled tasks" },
+    subCommands: {
+      add: cronAddCommand,
+      list: cronListCommand,
+      remove: cronRemoveCommand
+    }
+  });
   const main = defineCommand({
     meta: {
       name: "kon",
@@ -948,7 +1261,9 @@ function runCitty() {
       status: statusCommand,
       upload: uploadCommand,
       download: downloadCommand,
-      version: versionCommand
+      version: versionCommand,
+      skill: skillCommand,
+      cron: cronCommand
     }
   });
   runMain(main);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schuttdev/kon",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "type": "module",
   "description": "Lightweight gigai client for Claude code execution",
   "bin": {