@kortix/agent-tunnel 0.1.0 → 0.1.2

package/src/agent/cli.ts

@@ -1,11 +1,15 @@
 #!/usr/bin/env bun
-import { loadConfig } from './config';
+import { loadConfig, type TunnelConfig } from './config';
 import { TunnelAgent } from './agent';
 import { CapabilityRegistry } from './capabilities/index';
 import { createFilesystemCapability } from './capabilities/filesystem';
 import { createShellCapability } from './capabilities/shell';
 import { createDesktopCapability } from './capabilities/desktop';
 import { hostname, platform, arch, release } from 'os';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
 
 const c = {
   reset:   '\x1b[0m',
@@ -114,30 +118,14 @@ async function printStartup(config: { tunnelId: string; apiUrl: string }, capabi
   console.log('');
 }
 
-async function commandConnect(flags: Record<string, string>): Promise<void> {
-  const config = loadConfig({
-    token: flags.token,
-    tunnelId: flags['tunnel-id'],
-    apiUrl: flags['api-url'],
-  });
-
-  if (!config.token) {
-    console.error(`${c.red}${c.bold} error${c.reset} --token is required`);
-    process.exit(1);
-  }
-
-  if (!config.tunnelId) {
-    console.error(`${c.red}${c.bold} error${c.reset} --tunnel-id is required`);
-    process.exit(1);
-  }
-
+function startAgent(config: TunnelConfig): void {
   const registry = new CapabilityRegistry();
   registry.register(createFilesystemCapability(config));
   registry.register(createShellCapability(config));
   registry.register(createDesktopCapability());
 
   clearScreen();
-  await printStartup(config, registry.getCapabilityNames(), '0.1.0');
+  printStartup(config, registry.getCapabilityNames(), '0.1.2');
 
   const agent = new TunnelAgent(config, registry);
   agent.connect();
@@ -152,6 +140,152 @@ async function commandConnect(flags: Record<string, string>): Promise<void> {
   process.on('SIGINT', shutdown);
 }
 
+function openBrowser(url: string): void {
+  try {
+    const plat = platform();
+    if (plat === 'darwin') execSync(`open "${url}"`);
+    else if (plat === 'win32') execSync(`start "" "${url}"`);
+    else execSync(`xdg-open "${url}"`);
+  } catch {}
+}
+
+const CONFIG_DIR = join(homedir(), '.agent-tunnel');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+function saveCredentials(tunnelId: string, token: string, apiUrl: string): void {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  let existing: Record<string, unknown> = {};
+  if (existsSync(CONFIG_FILE)) {
+    try { existing = JSON.parse(readFileSync(CONFIG_FILE, 'utf-8')); } catch {}
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify({ ...existing, tunnelId, token, apiUrl }, null, 2));
+}
+
+async function commandConnectDeviceAuth(config: TunnelConfig): Promise<void> {
+  console.log('');
+  console.log(`  ${c.cyan}◆${c.reset} ${c.bold}Device Authorization${c.reset}`);
+  console.log('');
+
+  // Step 1: Create device auth request
+  let deviceCode: string;
+  let deviceSecret: string;
+  let verificationUrl: string;
+  let expiresAt: string;
+  let pollIntervalMs: number;
+
+  try {
+    const res = await fetch(`${config.apiUrl}/device-auth`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ machineHostname: hostname() }),
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      console.error(`  ${c.red}✗${c.reset} Failed to create device auth request: ${res.status} ${text.slice(0, 200)}`);
+      process.exit(1);
+    }
+    const data = await res.json();
+    deviceCode = data.deviceCode;
+    deviceSecret = data.deviceSecret;
+    verificationUrl = data.verificationUrl;
+    expiresAt = data.expiresAt;
+    pollIntervalMs = data.pollIntervalMs || 2000;
+  } catch (err) {
+    console.error(`  ${c.red}✗${c.reset} Failed to reach API at ${config.apiUrl}`);
+    process.exit(1);
+    return;
+  }
+
+  // Step 2: Display code and open browser
+  console.log(`  ${c.dim}Code:${c.reset}  ${c.bold}${c.white}${deviceCode}${c.reset}`);
+  console.log('');
+  console.log(`  ${c.dim}Open this URL on any device to approve:${c.reset}`);
+  console.log(`  ${c.cyan}${verificationUrl}${c.reset}`);
+  console.log('');
+
+  openBrowser(verificationUrl);
+
+  // Step 3: Poll for approval
+  const expiresAtMs = new Date(expiresAt).getTime();
+
+  while (true) {
+    const remaining = Math.max(0, Math.floor((expiresAtMs - Date.now()) / 1000));
+    if (remaining <= 0) {
+      console.log(`\n  ${c.red}✗${c.reset} Authorization expired. Please try again.`);
+      process.exit(1);
+    }
+
+    const min = Math.floor(remaining / 60);
+    const sec = remaining % 60;
+    process.stdout.write(`\r  ${c.dim}Waiting for approval... ${c.white}${min}:${sec.toString().padStart(2, '0')}${c.reset}  `);
+
+    try {
+      const res = await fetch(`${config.apiUrl}/device-auth/${deviceCode}/status?secret=${deviceSecret}`);
+      if (res.ok) {
+        const data = await res.json();
+
+        if (data.status === 'approved' && data.tunnelId && data.token) {
+          process.stdout.write('\r' + ' '.repeat(60) + '\r');
+          console.log(`  ${c.green}●${c.reset} ${c.bold}Authorized!${c.reset}`);
+          console.log('');
+
+          // Save credentials
+          saveCredentials(data.tunnelId, data.token, config.apiUrl);
+          console.log(`  ${c.dim}Credentials saved to ${CONFIG_FILE}${c.reset}`);
+          console.log('');
+
+          // Connect with received credentials
+          const fullConfig = loadConfig({
+            token: data.token,
+            tunnelId: data.tunnelId,
+            apiUrl: config.apiUrl,
+          });
+          startAgent(fullConfig);
+          return;
+        }
+
+        if (data.status === 'denied') {
+          process.stdout.write('\r' + ' '.repeat(60) + '\r');
+          console.log(`  ${c.red}✗${c.reset} Authorization denied.`);
+          process.exit(1);
+        }
+
+        if (data.status === 'expired') {
+          process.stdout.write('\r' + ' '.repeat(60) + '\r');
+          console.log(`  ${c.red}✗${c.reset} Authorization expired. Please try again.`);
+          process.exit(1);
+        }
+      }
+    } catch {}
+
+    await sleep(pollIntervalMs);
+  }
+}
+
+async function commandConnect(flags: Record<string, string>): Promise<void> {
+  const config = loadConfig({
+    token: flags.token,
+    tunnelId: flags['tunnel-id'],
+    apiUrl: flags['api-url'],
+  });
+
+  // If both token and tunnelId are provided, connect directly
+  if (config.token && config.tunnelId) {
+    startAgent(config);
+    return;
+  }
+
+  // If neither is provided, use device auth flow
+  if (!config.token && !config.tunnelId) {
+    await commandConnectDeviceAuth(config);
+    return;
+  }
+
+  // Partial — error
+  console.error(`${c.red}${c.bold} error${c.reset} Provide both --token and --tunnel-id, or neither (for device auth)`);
+  process.exit(1);
+}
+
 async function commandStatus(flags: Record<string, string>): Promise<void> {
   const config = loadConfig({
     token: flags.token,
@@ -192,13 +326,13 @@ function showHelp(): void {
   console.log(`  ${c.bold}Usage${c.reset}   ${c.dim}npx @kortix/agent-tunnel <command> [options]${c.reset}`);
   console.log('');
   console.log(`${c.gray}  ── Commands ────────────────────────────────────────${c.reset}`);
-  console.log(`  ${c.cyan}connect${c.reset}       Connect and start handling RPC requests`);
+  console.log(`  ${c.cyan}connect${c.reset}       Connect via device auth (opens browser)`);
   console.log(`  ${c.cyan}status${c.reset}        Check tunnel connection status`);
   console.log(`  ${c.cyan}help${c.reset}          Show this help message`);
   console.log('');
   console.log(`${c.gray}  ── Options ─────────────────────────────────────────${c.reset}`);
-  console.log(`  ${c.white}--token${c.reset} ${c.dim}<token>${c.reset}       API token ${c.dim}(or TUNNEL_TOKEN)${c.reset}`);
-  console.log(`  ${c.white}--tunnel-id${c.reset} ${c.dim}<id>${c.reset}     Tunnel ID ${c.dim}(or TUNNEL_ID)${c.reset}`);
+  console.log(`  ${c.white}--token${c.reset} ${c.dim}<token>${c.reset}       Skip device auth, connect directly`);
+  console.log(`  ${c.white}--tunnel-id${c.reset} ${c.dim}<id>${c.reset}     Tunnel ID ${c.dim}(required with --token)${c.reset}`);
   console.log(`  ${c.white}--api-url${c.reset} ${c.dim}<url>${c.reset}       API URL ${c.dim}(default: http://localhost:8080)${c.reset}`);
   console.log('');
   console.log(`  ${c.dim}Config: ~/.agent-tunnel/config.json${c.reset}`);

package/src/agent/config.ts

@@ -6,12 +6,17 @@ export interface TunnelConfig {
   token: string;
   tunnelId: string;
   apiUrl: string;
-  /** WS path on the server (default: '/ws'). Override for custom server mounts. */
   wsPath: string;
   maxFileSize: number;
   allowedPaths: string[];
   allowedCommands: string[];
+  blockedCommands: string[];
+  blockedPaths: string[];
   workingDir: string;
+  shellTimeout: number;
+  shellMaxTimeout: number;
+  shellMaxOutputSize: number;
+  shellEnvPassthrough: string[];
 }
 
 const CONFIG_DIR = join(homedir(), '.agent-tunnel');
@@ -23,7 +28,22 @@ const DEFAULTS: Partial<TunnelConfig> = {
   maxFileSize: 10 * 1024 * 1024,
   allowedPaths: [homedir()],
   allowedCommands: [],
+  blockedCommands: [],
+  blockedPaths: [
+    '/etc/shadow',
+    '/etc/passwd',
+    '/etc/sudoers',
+    '/etc/ssh',
+    '/root/.ssh',
+    '/proc',
+    '/sys',
+    '/dev',
+  ],
   workingDir: homedir(),
+  shellTimeout: 30_000,
+  shellMaxTimeout: 120_000,
+  shellMaxOutputSize: 1024 * 1024,
+  shellEnvPassthrough: ['PATH', 'HOME', 'USER', 'LANG', 'LC_ALL', 'LC_CTYPE', 'TMPDIR', 'NODE_ENV', 'HOSTNAME'],
 };
 
 export function loadConfig(overrides: Partial<TunnelConfig> = {}): TunnelConfig {

package/src/agent/security/command-validator.ts

@@ -1,42 +1,10 @@
-/**
- * Command Validator — defense-in-depth command injection prevention.
- *
- * Validates that shell commands:
- *   1. Are in the allowed commands list (if configured)
- *   2. Don't contain shell metacharacters
- *   3. Don't execute dangerous system commands
- */
-
-/** Commands that should never be executed via tunnel regardless of config. */
-const BLOCKED_COMMANDS = new Set([
-  'rm',
-  'rmdir',
-  'mkfs',
-  'dd',
-  'shutdown',
-  'reboot',
-  'halt',
-  'poweroff',
-  'init',
-  'systemctl',
-  'sudo',
-  'su',
-  'passwd',
-  'chown',
-  'chmod',
-  'chgrp',
-  'mount',
-  'umount',
-  'fdisk',
-  'parted',
-  'iptables',
-  'ufw',
-  'firewall-cmd',
-]);
-
 const SHELL_METACHAR_REGEX = /[;&|`$(){}[\]<>!#~]/;
 
-export function validateCommand(command: string, allowedCommands: string[]): void {
+export function validateCommand(
+  command: string,
+  allowedCommands: string[],
+  blockedCommands: string[],
+): void {
   if (!command || typeof command !== 'string') {
     throw new Error('Command is required');
   }
@@ -49,8 +17,8 @@ export function validateCommand(command: string, allowedCommands: string[]): voi
 
   const executable = trimmed.split(/\s+/)[0];
 
-  if (BLOCKED_COMMANDS.has(executable)) {
-    throw new Error(`Command "${executable}" is blocked for security reasons`);
+  if (blockedCommands.length > 0 && blockedCommands.includes(executable)) {
+    throw new Error(`Command "${executable}" is blocked`);
   }
 
   if (allowedCommands.length > 0) {

package/src/agent/security/path-validator.ts

@@ -5,25 +5,17 @@
  *   1. Are absolute
  *   2. Resolve to an absolute path (follows symlinks)
  *   3. Fall within allowed directories
- *   4. Don't hit sensitive system paths
+ *   4. Don't hit blocked paths (configurable)
  */
 
 import { resolve, normalize } from 'path';
 import { realpathSync } from 'fs';
 
-const SENSITIVE_PATHS = [
-  '/etc/shadow',
-  '/etc/passwd',
-  '/etc/sudoers',
-  '/etc/ssh',
-  '/root/.ssh',
-  '/proc',
-  '/sys',
-  '/dev',
-];
-
-
-export function validatePath(path: string, allowedPaths: string[]): void {
+export function validatePath(
+  path: string,
+  allowedPaths: string[],
+  blockedPaths: string[] = [],
+): void {
   if (!path) {
     throw new Error('Path is required');
   }
@@ -32,13 +24,18 @@ export function validatePath(path: string, allowedPaths: string[]): void {
   let resolved: string;
   try {
     resolved = realpathSync(normalized);
-  } catch {
-    resolved = normalized;
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT') {
+      resolved = normalized;
+    } else {
+      throw new Error(`Access denied: cannot resolve path "${path}" (${code})`);
+    }
   }
 
-  for (const sensitive of SENSITIVE_PATHS) {
-    if (resolved === sensitive || resolved.startsWith(sensitive + '/')) {
-      throw new Error(`Access denied: sensitive system path "${path}"`);
+  for (const blocked of blockedPaths) {
+    if (resolved === blocked || resolved.startsWith(blocked + '/')) {
+      throw new Error(`Access denied: blocked path "${path}"`);
     }
   }
 

package/src/agent/security/permission-guard.ts

@@ -50,7 +50,8 @@ export class PermissionGuard {
     }
 
     if (perm.expiresAt) {
-      if (new Date(perm.expiresAt) < new Date()) {
+      const expiry = new Date(perm.expiresAt).getTime();
+      if (isNaN(expiry) || expiry < Date.now()) {
         this.permissions.delete(permissionId);
         return false;
       }