@jx0/agency 0.2.1 → 0.4.1

package/src/api/lib/sync-skills.ts

@@ -0,0 +1,171 @@
+import { join } from "path";
+import { existsSync, readdirSync, copyFileSync, mkdirSync } from "fs";
+import { db } from "../db/client.js";
+import { getSSHConfig } from "./ssh.js";
+import { readMachines } from "../routes/machines.js";
+import { listRoles } from "./fs-store.js";
+
+export async function pushSkillsToAgent(agent: {
+  name: string;
+  role: string;
+  runtime: string;
+  machine?: string | null;
+}): Promise<void> {
+  const isLocal = resolveIsLocal(agent.machine);
+  if (isLocal && agent.runtime === "system") return;
+
+  const skillsSource = join(process.cwd(), `roles/${agent.role}/skills/`);
+  if (!existsSync(skillsSource)) return;
+
+  if (agent.runtime === "system" && !isLocal) {
+    if (!agent.machine) return;
+    const config = await getSSHConfig(agent.machine);
+    const proc = Bun.spawn(
+      [
+        "rsync",
+        "-az",
+        "--delete",
+        "-e",
+        config.sshCmd,
+        skillsSource,
+        `${config.dest}:~/agency/roles/${agent.role}/skills/`,
+      ],
+      { stdout: "inherit", stderr: "inherit" },
+    );
+    const code = await proc.exited;
+    if (code !== 0) {
+      console.error(`[sync-skills] rsync to ${agent.name} failed (exit ${code})`);
+    }
+  }
+
+  if (agent.runtime === "docker") {
+    const proc = Bun.spawn(
+      [
+        "docker",
+        "cp",
+        `${skillsSource}.`,
+        `agent-${agent.name}:/app/roles/${agent.role}/skills`,
+      ],
+      { stdout: "inherit", stderr: "inherit" },
+    );
+    const code = await proc.exited;
+    if (code !== 0) {
+      console.error(`[sync-skills] docker cp to ${agent.name} failed (exit ${code})`);
+    }
+  }
+}
+
+export async function pushRoleToAgent(agent: {
+  name: string;
+  role: string;
+  runtime: string;
+  machine?: string | null;
+}): Promise<void> {
+  const isLocal = resolveIsLocal(agent.machine);
+  if (isLocal && agent.runtime === "system") return;
+
+  const roleSource = join(process.cwd(), `roles/${agent.role}/`);
+  if (!existsSync(roleSource)) return;
+
+  if (agent.runtime === "system" && !isLocal) {
+    if (!agent.machine) return;
+    const config = await getSSHConfig(agent.machine);
+    const proc = Bun.spawn(
+      [
+        "rsync",
+        "-az",
+        "--delete",
+        "-e",
+        config.sshCmd,
+        roleSource,
+        `${config.dest}:~/agency/roles/${agent.role}/`,
+      ],
+      { stdout: "inherit", stderr: "inherit" },
+    );
+    const code = await proc.exited;
+    if (code !== 0) {
+      console.error(`[sync] rsync role to ${agent.name} failed (exit ${code})`);
+    }
+  }
+
+  if (agent.runtime === "docker") {
+    const proc = Bun.spawn(
+      [
+        "docker",
+        "cp",
+        `${roleSource}.`,
+        `agent-${agent.name}:/app/roles/${agent.role}`,
+      ],
+      { stdout: "inherit", stderr: "inherit" },
+    );
+    const code = await proc.exited;
+    if (code !== 0) {
+      console.error(`[sync] docker cp role to ${agent.name} failed (exit ${code})`);
+    }
+  }
+}
+
+export async function pushRoleToAllAgents(role: string): Promise<void> {
+  const agents = await db
+    .selectFrom("agents")
+    .where("status", "=", "active")
+    .where("role", "=", role)
+    .selectAll()
+    .execute();
+
+  await Promise.allSettled(
+    agents.map((a) =>
+      pushRoleToAgent({ name: a.name, role: a.role, runtime: (a as any).runtime ?? "system", machine: (a as any).machine }),
+    ),
+  );
+}
+
+export async function pushSkillsToAllAgents(): Promise<void> {
+  const agents = await db
+    .selectFrom("agents")
+    .where("status", "=", "active")
+    .selectAll()
+    .execute();
+
+  await Promise.allSettled(
+    agents.map((a) =>
+      pushSkillsToAgent({ name: a.name, role: a.role, runtime: (a as any).runtime ?? "system", machine: (a as any).machine }),
+    ),
+  );
+}
+
+/**
+ * Sync system-level files (from system/) to all role directories.
+ * These are Agency-managed files that apply to all agents regardless of role.
+ */
+export function syncSystemFilesToRoles(): void {
+  const systemDir = join(process.cwd(), "system");
+  if (!existsSync(systemDir)) return;
+
+  const roles = listRoles();
+  const systemFiles = readdirSync(systemDir).filter((f) => f.endsWith(".md"));
+
+  for (const role of roles) {
+    const roleDir = join(process.cwd(), "roles", role);
+    mkdirSync(roleDir, { recursive: true });
+
+    for (const file of systemFiles) {
+      const src = join(systemDir, file);
+      const dest = join(roleDir, file);
+      try {
+        copyFileSync(src, dest);
+      } catch (err) {
+        console.error(`[sync-system] failed to copy ${file} to ${role}:`, err);
+      }
+    }
+  }
+
+  console.log(`[sync-system] synced ${systemFiles.length} system file(s) to ${roles.length} role(s)`);
+}
+
+function resolveIsLocal(machineName?: string | null): boolean {
+  if (!machineName) return true;
+  const machines = readMachines();
+  const machine = machines.find((m) => m.name === machineName);
+  return machine?.auth === "local" ?? true;
+}

package/src/api/lib/tunnels.ts

@@ -1,58 +1,27 @@
 import type { Subprocess } from "bun";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { db } from "../db/client.js";
+import { getSSHConfig } from "./ssh.js";
 
 const tunnels = new Map<string, Subprocess>();
 
 const API_PORT = Number(process.env.PORT ?? 3100);
 
-async function getSSHConfig(): Promise<{ keyPath: string; user: string }> {
-  const rows = await db
-    .selectFrom("settings")
-    .where("category", "=", "ssh")
-    .selectAll()
-    .execute();
-
-  const settings: Record<string, string> = {};
-  for (const r of rows) settings[r.key] = r.value;
-
-  const user = settings["ssh.user"] || "ubuntu";
-  const privateKey = settings["ssh.private_key"] || "";
-
-  if (!privateKey) {
-    throw new Error("SSH private key not configured. Set it in Settings → SSH.");
-  }
-
-  // Write key to a temp file (SSH requires a file path)
-  const keyDir = path.join(os.tmpdir(), "agency-ssh");
-  fs.mkdirSync(keyDir, { recursive: true, mode: 0o700 });
-  const keyPath = path.join(keyDir, "agent_key");
-  fs.writeFileSync(keyPath, privateKey + "\n", { mode: 0o600 });
-
-  return { keyPath, user };
-}
-
-export async function startTunnel(name: string, host: string): Promise<void> {
+export async function startTunnel(name: string, host: string, machineName?: string): Promise<void> {
   // Kill existing tunnel if any
   stopTunnel(name);
 
-  const { keyPath, user } = await getSSHConfig();
+  const config = await getSSHConfig(machineName);
 
   const args = [
-    "ssh",
-    "-i", keyPath,
-    "-o", "StrictHostKeyChecking=no",
+    ...config.args,
     "-o", "ServerAliveInterval=30",
     "-o", "ServerAliveCountMax=3",
     "-o", "ExitOnForwardFailure=yes",
     "-N",               // no command, just tunnel
     "-R", `${API_PORT}:localhost:${API_PORT}`,  // reverse tunnel: remote:3100 -> local:3100
-    `${user}@${host}`,
+    config.dest,
   ];
 
-  console.log(`[tunnel] opening reverse tunnel to ${name} (${user}@${host})`);
+  console.log(`[tunnel] opening reverse tunnel to ${name} (${config.dest})`);
 
   const proc = Bun.spawn(args, {
     stdout: "inherit",
@@ -69,7 +38,7 @@ export async function startTunnel(name: string, host: string): Promise<void> {
     setTimeout(() => {
       // Only restart if no new tunnel was created
       if (!tunnels.has(name)) {
-        startTunnel(name, host).catch((err) =>
+        startTunnel(name, host, machineName).catch((err) =>
           console.error(`[tunnel] failed to restart tunnel for ${name}:`, err.message)
         );
       }