poke-gate 0.0.8 → 0.1.0

package/src/agents.js

@@ -0,0 +1,257 @@
+import { readdirSync, readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { exec } from "node:child_process";
+
+const CONFIG_DIR = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+const AGENTS_DIR = join(CONFIG_DIR, "poke-gate", "agents");
+
+const MIN_INTERVAL_MS = 10 * 60 * 1000;
+
+function log(msg) {
+  const ts = new Date().toISOString().slice(11, 19);
+  console.log(`[${ts}] [agents] ${msg}`);
+}
+
+function parseInterval(token) {
+  const match = token.match(/^(\d+)(m|h)$/);
+  if (!match) return null;
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+  const ms = unit === "h" ? value * 60 * 60 * 1000 : value * 60 * 1000;
+  if (ms < MIN_INTERVAL_MS) return null;
+  return ms;
+}
+
+function parseFrontmatter(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const match = content.match(/\/\*\*[\s\S]*?\*\//);
+    if (!match) return {};
+    const block = match[0];
+    const meta = {};
+    const lines = block.split("\n");
+    for (const line of lines) {
+      const m = line.match(/@(\w+)\s+(.*)/);
+      if (m) {
+        const key = m[1].trim();
+        const value = m[2].replace(/\*\/$/, "").trim();
+        if (key === "env") {
+          if (!meta.env) meta.env = [];
+          meta.env.push(value);
+        } else {
+          meta[key] = value;
+        }
+      }
+    }
+    return meta;
+  } catch {
+    return {};
+  }
+}
+
+function parseEnvFile(filePath) {
+  const env = {};
+  if (!existsSync(filePath)) return env;
+  const lines = readFileSync(filePath, "utf-8").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    let value = trimmed.slice(eqIdx + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    env[key] = value;
+  }
+  return env;
+}
+
+export function discoverAgents() {
+  if (!existsSync(AGENTS_DIR)) {
+    mkdirSync(AGENTS_DIR, { recursive: true });
+    return [];
+  }
+
+  const files = readdirSync(AGENTS_DIR).filter((f) => f.endsWith(".js"));
+  const agents = [];
+
+  for (const file of files) {
+    const parts = file.replace(/\.js$/, "").split(".");
+    if (parts.length < 2) continue;
+
+    const intervalToken = parts[parts.length - 1];
+    const name = parts.slice(0, -1).join(".");
+    const intervalMs = parseInterval(intervalToken);
+
+    if (!intervalMs) {
+      log(`Skipping ${file}: invalid or too short interval (min 10m)`);
+      continue;
+    }
+
+    const agentPath = join(AGENTS_DIR, file);
+    const meta = parseFrontmatter(agentPath);
+
+    agents.push({
+      name,
+      file,
+      path: agentPath,
+      intervalToken,
+      intervalMs,
+      envFile: join(AGENTS_DIR, `.env.${name}`),
+      meta,
+    });
+  }
+
+  return agents;
+}
+
+function runAgentProcess(agent) {
+  const agentEnv = parseEnvFile(agent.envFile);
+  const env = { ...process.env, ...agentEnv };
+
+  log(`Running agent: ${agent.name} (${agent.file})`);
+
+  return new Promise((resolve) => {
+    exec(`node "${agent.path}"`, {
+      env,
+      timeout: 5 * 60 * 1000,
+      maxBuffer: 1024 * 1024,
+      cwd: AGENTS_DIR,
+    }, (error, stdout, stderr) => {
+      if (stdout.trim()) log(`[${agent.name}] ${stdout.trim()}`);
+      if (stderr.trim()) log(`[${agent.name}] stderr: ${stderr.trim()}`);
+      if (error) log(`[${agent.name}] exited with code ${error.code ?? 1}`);
+      else log(`[${agent.name}] completed`);
+      resolve();
+    });
+  });
+}
+
+export async function runAgent(name) {
+  const agents = discoverAgents();
+  const agent = agents.find((a) => a.name === name);
+  if (!agent) {
+    const allFiles = readdirSync(AGENTS_DIR).filter((f) => f.endsWith(".js"));
+    const match = allFiles.find((f) => f.startsWith(name + "."));
+    if (match) {
+      const parts = match.replace(/\.js$/, "").split(".");
+      const intervalToken = parts[parts.length - 1];
+      const intervalMs = parseInterval(intervalToken);
+      await runAgentProcess({
+        name,
+        file: match,
+        path: join(AGENTS_DIR, match),
+        intervalToken,
+        intervalMs: intervalMs || 0,
+        envFile: join(AGENTS_DIR, `.env.${name}`),
+      });
+      return;
+    }
+    console.error(`Agent "${name}" not found in ${AGENTS_DIR}`);
+    console.error("Available agents:", agents.map((a) => a.name).join(", ") || "none");
+    process.exit(1);
+  }
+  await runAgentProcess(agent);
+}
+
+const REPO_BASE = "https://raw.githubusercontent.com/f/poke-gate/main/examples/agents";
+
+export async function downloadAgent(name) {
+  mkdirSync(AGENTS_DIR, { recursive: true });
+
+  console.log(`Fetching agent "${name}" from GitHub...`);
+
+  const indexRes = await fetch(`${REPO_BASE}/`).catch(() => null);
+
+  const jsUrl = `${REPO_BASE}/${name}`;
+  const envUrl = `${REPO_BASE}/.env.${name}`;
+
+  // Try to find the exact file first, or search for name.*.js pattern
+  let jsFileName = null;
+  let jsContent = null;
+
+  // Try direct match (user might pass "beeper.1h.js")
+  let res = await fetch(`${REPO_BASE}/${name}`).catch(() => null);
+  if (res?.ok) {
+    jsFileName = name;
+    jsContent = await res.text();
+  }
+
+  // Try with .js extension
+  if (!jsContent) {
+    res = await fetch(`${REPO_BASE}/${name}.js`).catch(() => null);
+    if (res?.ok) {
+      jsFileName = `${name}.js`;
+      jsContent = await res.text();
+    }
+  }
+
+  // Try common intervals
+  if (!jsContent) {
+    for (const interval of ["10m", "30m", "1h", "2h", "6h", "12h", "24h"]) {
+      res = await fetch(`${REPO_BASE}/${name}.${interval}.js`).catch(() => null);
+      if (res?.ok) {
+        jsFileName = `${name}.${interval}.js`;
+        jsContent = await res.text();
+        break;
+      }
+    }
+  }
+
+  if (!jsContent) {
+    console.error(`Agent "${name}" not found in the repository.`);
+    console.error(`Browse available agents: https://github.com/f/poke-gate/tree/main/examples/agents`);
+    process.exit(1);
+  }
+
+  const dest = join(AGENTS_DIR, jsFileName);
+  writeFileSync(dest, jsContent);
+  console.log(`  Saved: ${dest}`);
+
+  // Try to download matching .env file
+  const envName = name.split(".")[0];
+  const envRes = await fetch(`${REPO_BASE}/.env.${envName}`).catch(() => null);
+  if (envRes?.ok) {
+    const envContent = await envRes.text();
+    const envDest = join(AGENTS_DIR, `.env.${envName}`);
+    if (!existsSync(envDest)) {
+      writeFileSync(envDest, envContent);
+      console.log(`  Saved: ${envDest}`);
+      console.log(`\n  Edit the env file with your credentials:`);
+      console.log(`    nano ${envDest}`);
+    } else {
+      console.log(`  .env.${envName} already exists, skipped.`);
+    }
+  }
+
+  console.log(`\n  Test it: npx poke-gate run-agent ${envName}`);
+}
+
+export function startAgentScheduler() {
+  const agents = discoverAgents();
+
+  if (agents.length === 0) {
+    log("No agents found. Add scripts to ~/.config/poke-gate/agents/");
+    return;
+  }
+
+  log(`Found ${agents.length} agent(s):`);
+  for (const agent of agents) {
+    const interval = agent.intervalToken;
+    const hasEnv = existsSync(agent.envFile);
+    const desc = agent.meta.name || agent.name;
+    log(`  ${desc} (every ${interval}${hasEnv ? ", has .env" : ""})`);
+  }
+
+  for (const agent of agents) {
+    runAgentProcess(agent);
+
+    setInterval(() => {
+      runAgentProcess(agent);
+    }, agent.intervalMs);
+  }
+}

package/src/app.js

@@ -1,46 +1,35 @@
 import { startMcpServer, enableLogging } from "./mcp-server.js";
 import { startTunnel } from "./tunnel.js";
-import { Poke } from "poke";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
+import { startAgentScheduler } from "./agents.js";
+import { Poke, isLoggedIn, login, getToken } from "poke";
 
 const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
 enableLogging(verbose);
 
-function resolveToken() {
-  if (process.env.POKE_API_KEY) return process.env.POKE_API_KEY;
-
-  const configDir = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
-
-  try {
-    const cfg = JSON.parse(readFileSync(join(configDir, "poke-gate", "config.json"), "utf-8"));
-    if (cfg.apiKey) return cfg.apiKey;
-  } catch {}
-
-  try {
-    const creds = JSON.parse(readFileSync(join(configDir, "poke", "credentials.json"), "utf-8"));
-    if (creds.token) return creds.token;
-  } catch {}
-
-  return null;
-}
-
 function log(msg) {
   const ts = new Date().toISOString().slice(11, 19);
   console.log(`[${ts}] ${msg}`);
 }
 
-const API_KEY = resolveToken();
+async function ensureAuthenticated() {
+  if (!isLoggedIn()) {
+    log("Signing in to Poke...");
+    await login();
+  }
+
+  const token = getToken();
+  if (!token) {
+    throw new Error("Authentication failed: no token returned by Poke SDK.");
+  }
 
-if (!API_KEY) {
-  console.error("No credentials found. Run: npx poke-gate");
-  process.exit(1);
+  return token;
 }
 
 async function main() {
   log("poke-gate starting...");
 
+  const token = await ensureAuthenticated();
+
   const { port } = await startMcpServer();
   log(`MCP server on port ${port}`);
 
@@ -48,15 +37,15 @@ async function main() {
 
   log("Connecting tunnel to Poke...");
   try {
-    const { info } = await startTunnel({
-      apiKey: API_KEY,
+    await startTunnel({
       mcpUrl,
       onEvent: (type, data) => {
         switch (type) {
           case "connected":
             log(`Tunnel connected (${data.connectionId})`);
             log("Ready — your Poke agent can now access this machine.");
-            notifyPoke(data.connectionId);
+            notifyPoke(data.connectionId, token);
+            startAgentScheduler();
             break;
           case "disconnected":
             log("Tunnel disconnected. Reconnecting...");
@@ -79,13 +68,14 @@ async function main() {
   }
 }
 
-async function notifyPoke(connectionId) {
+async function notifyPoke(connectionId, token) {
   try {
-    const poke = new Poke({ apiKey: API_KEY });
+    const poke = new Poke({ token });
     await poke.sendMessage(
-      `Poke macOS Gate is connected. Tunnel ID: ${connectionId}. ` +
-      `You now have access to this machine's terminal, files, and screen. ` +
-      `Use the available tools (run_command, read_file, write_file, list_directory, system_info, read_image, take_screenshot) to help the user.`
+      `Hey! I've connected my computer to you via Poke Gate (tunnel: ${connectionId}). ` +
+      `You can now run commands, read and write files, list directories, take screenshots, and check system info on my machine. ` +
+      `Just use the tools whenever I ask you to do something on my computer.` +
+      `Now reply me in my language "now I am connected to your computer".`
     );
     log("Notified Poke agent about connection.");
   } catch (err) {

package/src/mcp-server.js

@@ -1,5 +1,5 @@
 import http from "node:http";
-import { execSync, exec } from "node:child_process";
+import { exec } from "node:child_process";
 import { readFileSync, writeFileSync, readdirSync, statSync } from "node:fs";
 import { hostname, platform, arch, uptime, totalmem, freemem, homedir } from "node:os";
 import { join, resolve, extname } from "node:path";
@@ -108,7 +108,7 @@ const TOOLS = [
 function runCommand(command, cwd) {
   return new Promise((res) => {
     const dir = cwd || homedir();
-    const child = exec(command, {
+    exec(command, {
       cwd: dir,
       timeout: COMMAND_TIMEOUT,
       maxBuffer: 1024 * 1024,
@@ -348,7 +348,7 @@ export function startMcpServer(port = 0) {
               res.end();
             }
           }
-        } catch (err) {
+        } catch {
           res.writeHead(400, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32700, message: "Parse error" }, id: null }));
         }

package/src/tunnel.js

@@ -19,11 +19,12 @@ function saveState(state) {
   writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
 }
 
-async function cleanupOldConnection(apiKey) {
+async function cleanupOldConnection() {
   const state = loadState();
   if (!state.connectionId) return;
 
-  const token = getToken() || apiKey;
+  const token = getToken();
+  if (!token) return;
   const base = process.env.POKE_API ?? "https://poke.com/api/v1";
 
   try {
@@ -34,15 +35,18 @@ async function cleanupOldConnection(apiKey) {
   } catch {}
 }
 
-export async function startTunnel({ apiKey, mcpUrl, onEvent }) {
-  await cleanupOldConnection(apiKey);
+export async function startTunnel({ mcpUrl, onEvent }) {
+  await cleanupOldConnection();
 
   const token = getToken();
+  if (!token) {
+    throw new Error("No Poke auth token available for tunnel.");
+  }
 
   const tunnel = new PokeTunnel({
     url: mcpUrl,
     name: "poke-gate",
-    token: token || apiKey,
+    token,
     cleanupOnStop: false,
   });