@sentropic/remote-cli 0.0.3

package/dist/chunk-Z277FK2S.js

@@ -0,0 +1,294 @@
+import {
+  getTunnel
+} from "./chunk-E3GXAKJ3.js";
+
+// src/h2a-bridge.ts
+import { spawnSync } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var H2A_POD_ROOT = "h2a-workspace/.h2a";
+function defaultLocalH2aRoot() {
+  return join(homedir(), "h2a-workspace", ".h2a");
+}
+function instanceInboxDir(instance) {
+  return instance.replace(/:/g, "__");
+}
+function profileTool(profile) {
+  switch (profile) {
+    case "claude":
+    case "claude-code":
+      return "claude";
+    case "codex":
+      return "codex";
+    case "agy":
+    case "antigravity":
+      return "agy";
+    case "gemini":
+    case "mistral":
+      return profile;
+    default:
+      return profile && profile.length > 0 ? profile : "claude";
+  }
+}
+function defaultPodInstance(sessionId, profile) {
+  return `${profileTool(profile)}:remote:${sessionId}`;
+}
+var SAFE_ENTRY = /^[A-Za-z0-9][A-Za-z0-9._-]*\/[A-Za-z0-9][A-Za-z0-9._-]*\.json$/;
+function planBridge(args) {
+  const { podInstanceDirs } = args;
+  const split = (entry) => {
+    const slash = entry.indexOf("/");
+    return { dir: entry.slice(0, slash), file: entry.slice(slash + 1) };
+  };
+  let skipped = 0;
+  let ignored = 0;
+  const podSet = /* @__PURE__ */ new Set();
+  const pull = [];
+  const push = [];
+  for (const entry of args.podFiles) {
+    if (!SAFE_ENTRY.test(entry)) {
+      ignored += 1;
+      continue;
+    }
+    podSet.add(entry);
+  }
+  const localSet = /* @__PURE__ */ new Set();
+  for (const entry of args.localFiles) {
+    if (!SAFE_ENTRY.test(entry)) {
+      ignored += 1;
+      continue;
+    }
+    localSet.add(entry);
+  }
+  for (const entry of podSet) {
+    const f = split(entry);
+    if (podInstanceDirs.has(f.dir)) continue;
+    if (localSet.has(entry)) skipped += 1;
+    else pull.push(f);
+  }
+  for (const entry of localSet) {
+    const f = split(entry);
+    if (!podInstanceDirs.has(f.dir)) continue;
+    if (podSet.has(entry)) skipped += 1;
+    else push.push(f);
+  }
+  return { pull, push, skipped, ignored };
+}
+function parsePodListing(out) {
+  const instances = [];
+  const files = [];
+  let section = "none";
+  for (const raw of out.split("\n")) {
+    const line = raw.trim();
+    if (line === "==INSTANCES==") {
+      section = "instances";
+      continue;
+    }
+    if (line === "==FILES==") {
+      section = "files";
+      continue;
+    }
+    if (line.length === 0) continue;
+    if (section === "instances") instances.push(line);
+    else if (section === "files") files.push(line);
+  }
+  return { instances, files };
+}
+function expandHome(p) {
+  return p.startsWith("~") ? join(homedir(), p.slice(1)) : p;
+}
+function execPod(tunnel, pod, script, input) {
+  const args = ["-n", tunnel.namespace, "exec"];
+  if (input !== void 0) args.push("-i");
+  args.push(pod, "-c", "session-agent", "--", "bash", "-lc", script);
+  const env = { ...process.env };
+  if (tunnel.kubeconfig) env.KUBECONFIG = expandHome(tunnel.kubeconfig);
+  const r = spawnSync("kubectl", args, {
+    encoding: "utf8",
+    env,
+    maxBuffer: 64 * 1024 * 1024,
+    ...input !== void 0 ? { input } : {}
+  });
+  if (r.status !== 0) {
+    throw new Error(
+      `kubectl exec failed: ${(r.stderr || "").trim().slice(0, 200)}`
+    );
+  }
+  return r.stdout;
+}
+function podReadme(podInboxDir) {
+  return [
+    "# h2a store (bridged)",
+    "",
+    "This directory is an h2a file store kept in sync with the operator's",
+    "local ~/h2a-workspace/.h2a by `remote h2a bridge` (no h2a binary needed",
+    "in this Pod).",
+    "",
+    "To MESSAGE another agent, write a JSON envelope",
+    '  { "protocol": "sentropic.h2a", "version": "0.1", "id": "env:<ts>:<slug>",',
+    '    "type": "event", "actor": { "instance", "role", "scope" }, "body", "createdAt" }',
+    "to inbox/<instance-dir>/env__<ts>__<slug>.json, where <instance-dir> is",
+    'the target instance id with ":" replaced by "__"',
+    "(claude:track:abc -> claude__track__abc).",
+    "",
+    `Your own inbox is inbox/${podInboxDir}/ \u2014 check it for new envelopes.`,
+    "The bridge never deletes files; acks/cleanup belong to h2a on the local",
+    "side. Existing file names are never overwritten.",
+    ""
+  ].join("\n");
+}
+function listLocalInbox(localRoot) {
+  const inbox = join(localRoot, "inbox");
+  if (!existsSync(inbox)) return [];
+  const entries = [];
+  for (const dir of readdirSync(inbox, { withFileTypes: true })) {
+    if (!dir.isDirectory()) continue;
+    for (const f of readdirSync(join(inbox, dir.name), {
+      withFileTypes: true
+    })) {
+      if (f.isFile() && f.name.endsWith(".json"))
+        entries.push(`${dir.name}/${f.name}`);
+    }
+  }
+  return entries;
+}
+async function bridgeSession(sessionId, options = {}) {
+  const stderr = options.stderr ?? process.stderr;
+  const tunnel = getTunnel();
+  if (!tunnel) {
+    throw new Error(
+      "h2a bridge needs a tunnel configured (remote config tunnel \u2026)"
+    );
+  }
+  const pod = `session-${sessionId}`;
+  const localRoot = options.localRoot ?? defaultLocalH2aRoot();
+  const podInbox = `$HOME/${H2A_POD_ROOT}/inbox`;
+  const defaultDir = instanceInboxDir(
+    defaultPodInstance(sessionId, options.profile)
+  );
+  const scaffold = execPod(
+    tunnel,
+    pod,
+    [
+      `root="$HOME/${H2A_POD_ROOT}"`,
+      `if [ -d "$root/inbox" ]; then echo h2a-store-exists; else`,
+      `mkdir -p "$root/inbox/${defaultDir}"`,
+      `cat > "$root/README.md" <<'H2ADOC'`,
+      podReadme(defaultDir),
+      `H2ADOC`,
+      `echo h2a-store-created`,
+      `fi`
+    ].join("\n")
+  );
+  const scaffolded = scaffold.includes("h2a-store-created");
+  const listing = parsePodListing(
+    execPod(
+      tunnel,
+      pod,
+      [
+        `cd "$HOME/${H2A_POD_ROOT}" 2>/dev/null || exit 0`,
+        `echo ==INSTANCES==`,
+        `sed -n 's/.*"instance"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/p' registry/instances.jsonl 2>/dev/null`,
+        `echo ==FILES==`,
+        `shopt -s nullglob`,
+        `for f in inbox/*/*.json; do printf '%s\\n' "\${f#inbox/}"; done`
+      ].join("\n")
+    )
+  );
+  const podInstanceDirs = /* @__PURE__ */ new Set([defaultDir]);
+  for (const instance of listing.instances) {
+    podInstanceDirs.add(instanceInboxDir(instance));
+  }
+  const plan = planBridge({
+    podFiles: listing.files,
+    localFiles: listLocalInbox(localRoot),
+    podInstanceDirs
+  });
+  if (plan.ignored > 0) {
+    stderr.write(
+      `[remote] h2a bridge ${sessionId}: ignored ${plan.ignored} unsafe inbox entry name(s)
+`
+    );
+  }
+  let pulled = 0;
+  let pushed = 0;
+  let skipped = plan.skipped;
+  let failed = 0;
+  for (const f of plan.pull) {
+    const dst = join(localRoot, "inbox", f.dir, f.file);
+    if (existsSync(dst)) {
+      skipped += 1;
+      continue;
+    }
+    try {
+      const b64 = execPod(
+        tunnel,
+        pod,
+        `base64 < "${podInbox}/${f.dir}/${f.file}" | tr -d '\\n'`
+      );
+      mkdirSync(join(localRoot, "inbox", f.dir), { recursive: true });
+      writeFileSync(dst, Buffer.from(b64.trim(), "base64"));
+      pulled += 1;
+    } catch (error) {
+      failed += 1;
+      stderr.write(
+        `[remote] h2a bridge ${sessionId}: pull ${f.dir}/${f.file} failed: ${String(
+          error instanceof Error ? error.message : error
+        ).slice(0, 160)}
+`
+      );
+    }
+  }
+  for (const f of plan.push) {
+    const src = join(localRoot, "inbox", f.dir, f.file);
+    try {
+      const payload = readFileSync(src).toString("base64");
+      const out = execPod(
+        tunnel,
+        pod,
+        [
+          `d="${podInbox}/${f.dir}"; f="$d/${f.file}"`,
+          `mkdir -p "$d"`,
+          `if [ -e "$f" ]; then echo h2a-exists; else base64 -d > "$f" && echo h2a-written; fi`
+        ].join("\n"),
+        payload
+      );
+      if (out.includes("h2a-written")) pushed += 1;
+      else skipped += 1;
+    } catch (error) {
+      failed += 1;
+      stderr.write(
+        `[remote] h2a bridge ${sessionId}: push ${f.dir}/${f.file} failed: ${String(
+          error instanceof Error ? error.message : error
+        ).slice(0, 160)}
+`
+      );
+    }
+  }
+  return {
+    sessionId,
+    pulled,
+    pushed,
+    skipped,
+    failed,
+    scaffolded,
+    podInstanceDirs: [...podInstanceDirs].sort()
+  };
+}
+
+export {
+  H2A_POD_ROOT,
+  defaultLocalH2aRoot,
+  instanceInboxDir,
+  defaultPodInstance,
+  planBridge,
+  parsePodListing,
+  bridgeSession
+};

package/dist/h2a-bridge-FPB5D3TB.js

@@ -0,0 +1,20 @@
+import {
+  H2A_POD_ROOT,
+  bridgeSession,
+  defaultLocalH2aRoot,
+  defaultPodInstance,
+  instanceInboxDir,
+  parsePodListing,
+  planBridge
+} from "./chunk-Z277FK2S.js";
+import "./chunk-E3GXAKJ3.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  H2A_POD_ROOT,
+  bridgeSession,
+  defaultLocalH2aRoot,
+  defaultPodInstance,
+  instanceInboxDir,
+  parsePodListing,
+  planBridge
+};