dextunnel 0.1.0

package/src/bin/mobile-proof.mjs

@@ -0,0 +1,164 @@
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+function printUsage() {
+  console.log(
+    "Usage: node src/bin/mobile-proof.mjs [--base-url http://127.0.0.1:4317] [--surface remote|host] [--transport-probe-send] [--no-native-probe-send] [--network-profile weak-mobile|weak-mobile-reconnect] [--proxy-port 4417]"
+  );
+}
+
+function parseArgs(argv) {
+  const options = {
+    baseUrl: "http://127.0.0.1:4317",
+    nativeProbeSend: true,
+    networkProfile: "",
+    proxyPort: 4417,
+    surface: "remote"
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === "--help" || arg === "-h") {
+      printUsage();
+      process.exit(0);
+    }
+
+    if (arg === "--base-url") {
+      options.baseUrl = argv[index + 1] || options.baseUrl;
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--surface") {
+      options.surface = argv[index + 1] || options.surface;
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--network-profile") {
+      options.networkProfile = argv[index + 1] || options.networkProfile;
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--proxy-port") {
+      options.proxyPort = Number(argv[index + 1]) || options.proxyPort;
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--no-probe-send" || arg === "--no-native-probe-send") {
+      options.nativeProbeSend = false;
+      continue;
+    }
+
+    if (arg === "--transport-probe-send") {
+      options.transportProbeSend = true;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+}
+
+function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd || process.cwd(),
+      env: process.env,
+      stdio: "inherit"
+    });
+
+    child.on("error", reject);
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        reject(new Error(`${command} exited via signal ${signal}`));
+        return;
+      }
+
+      if (code !== 0) {
+        reject(new Error(`${command} exited with code ${code}`));
+        return;
+      }
+
+      resolve();
+    });
+  });
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  const repoRoot = path.resolve(__dirname, "..", "..");
+  const nativeDir = path.join(repoRoot, "native", "apple");
+  let effectiveBaseUrl = options.baseUrl;
+  let proxyChild = null;
+
+  if (options.networkProfile) {
+    const proxyScript = path.join(repoRoot, "src", "bin", "mobile-link-proxy.mjs");
+    proxyChild = spawn(process.execPath, [
+      proxyScript,
+      "--target-base-url",
+      options.baseUrl,
+      "--listen-port",
+      String(options.proxyPort),
+      "--profile",
+      options.networkProfile
+    ], {
+      cwd: repoRoot,
+      env: process.env,
+      stdio: "inherit"
+    });
+
+    proxyChild.on("error", (error) => {
+      console.error(`[mobile-proof] proxy failed: ${error.message}`);
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    effectiveBaseUrl = `http://127.0.0.1:${options.proxyPort}`;
+  }
+
+  const transportArgs = [
+    path.join(repoRoot, "src", "bin", "mobile-transport-smoke.mjs"),
+    "--base-url",
+    effectiveBaseUrl,
+    "--surface",
+    options.surface
+  ];
+  if (options.transportProbeSend) {
+    transportArgs.push("--probe-send");
+  }
+
+  const nativeArgs = [
+    "run",
+    "DextunnelNativeBridgeSmoke",
+    "--base-url",
+    effectiveBaseUrl,
+    "--surface",
+    options.surface
+  ];
+  if (options.nativeProbeSend) {
+    nativeArgs.push("--probe-send");
+  }
+
+  try {
+    console.log(`[mobile-proof] transport smoke -> ${effectiveBaseUrl} (${options.surface})`);
+    await runCommand(process.execPath, transportArgs, { cwd: repoRoot });
+    console.log("[mobile-proof] native bridge smoke");
+    await runCommand("swift", nativeArgs, { cwd: nativeDir });
+    console.log("[mobile-proof] complete");
+  } finally {
+    if (proxyChild && proxyChild.exitCode == null) {
+      proxyChild.kill("SIGTERM");
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(`[mobile-proof] failed: ${error.message}`);
+  process.exit(1);
+});

package/src/bin/mobile-transport-smoke.mjs

@@ -0,0 +1,200 @@
+import { performance } from "node:perf_hooks";
+
+function parseArgs(argv) {
+  const options = {
+    baseUrl: "http://127.0.0.1:4317",
+    json: false,
+    probeSend: false,
+    surface: "remote"
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--base-url" && argv[index + 1]) {
+      options.baseUrl = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (argument === "--surface" && argv[index + 1]) {
+      options.surface = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (argument === "--probe-send") {
+      options.probeSend = true;
+      continue;
+    }
+    if (argument === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (argument === "--help" || argument === "-h") {
+      printHelpAndExit(0);
+    }
+  }
+
+  return options;
+}
+
+function printHelpAndExit(code = 0) {
+  console.log("Usage: node src/bin/mobile-transport-smoke.mjs [--base-url http://127.0.0.1:4317] [--surface remote|host] [--probe-send] [--json]");
+  process.exit(code);
+}
+
+async function measuredJson(url, init = {}) {
+  const startedAt = performance.now();
+  const response = await fetch(url, init);
+  const rawText = await response.text();
+  const elapsedMs = Math.round(performance.now() - startedAt);
+  const bytes = Buffer.byteLength(rawText || "", "utf8");
+  const payload = rawText ? JSON.parse(rawText) : null;
+  if (!response.ok) {
+    const error = new Error(payload?.error || payload?.message || response.statusText || "Request failed.");
+    error.status = response.status;
+    error.payload = payload;
+    throw error;
+  }
+  return {
+    bytes,
+    elapsedMs,
+    payload,
+    status: response.status,
+    url
+  };
+}
+
+function surfaceHeaders(token) {
+  return {
+    "x-dextunnel-surface-token": token
+  };
+}
+
+function summarizeMetric(name, result) {
+  return {
+    bytes: result.bytes,
+    elapsedMs: result.elapsedMs,
+    name,
+    status: result.status
+  };
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const baseUrl = new URL(options.baseUrl);
+  const bootstrapUrl = new URL("/api/codex-app-server/bootstrap", baseUrl);
+  bootstrapUrl.searchParams.set("surface", options.surface);
+
+  const bootstrap = await measuredJson(bootstrapUrl);
+  const accessToken = bootstrap.payload?.accessToken;
+  if (!accessToken) {
+    throw new Error("Bootstrap did not return a surface token.");
+  }
+
+  const metrics = [summarizeMetric("bootstrap", bootstrap)];
+
+  const liveState = await measuredJson(new URL("/api/codex-app-server/live-state", baseUrl), {
+    headers: surfaceHeaders(accessToken)
+  });
+  metrics.push(summarizeMetric("live-state", liveState));
+
+  const threads = await measuredJson(new URL("/api/codex-app-server/threads", baseUrl), {
+    headers: surfaceHeaders(accessToken)
+  });
+  metrics.push(summarizeMetric("threads", threads));
+
+  const refresh = await measuredJson(new URL("/api/codex-app-server/refresh", baseUrl), {
+    headers: surfaceHeaders(accessToken),
+    method: "POST"
+  });
+  metrics.push(summarizeMetric("refresh", refresh));
+
+  const selectedThreadId = refresh.payload?.state?.selectedThreadId || liveState.payload?.selectedThreadId || null;
+  const selectedProjectCwd = refresh.payload?.state?.selectedProjectCwd || liveState.payload?.selectedProjectCwd || null;
+
+  if (selectedThreadId || selectedProjectCwd) {
+    const selection = await measuredJson(new URL("/api/codex-app-server/selection", baseUrl), {
+      body: JSON.stringify({
+        cwd: selectedProjectCwd,
+        threadId: selectedThreadId
+      }),
+      headers: {
+        ...surfaceHeaders(accessToken),
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+    metrics.push(summarizeMetric("selection", selection));
+  }
+
+  if (options.probeSend) {
+    if (!selectedThreadId) {
+      throw new Error("Probe send requires a selected thread.");
+    }
+    const stamp = new Date().toISOString().replaceAll(":", "").replaceAll(".", "");
+    const claim = await measuredJson(new URL("/api/codex-app-server/control", baseUrl), {
+      body: JSON.stringify({
+        action: "claim",
+        reason: "transport_smoke",
+        threadId: selectedThreadId
+      }),
+      headers: {
+        ...surfaceHeaders(accessToken),
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+    metrics.push(summarizeMetric("claim", claim));
+
+    const send = await measuredJson(new URL("/api/codex-app-server/turn", baseUrl), {
+      body: JSON.stringify({
+        attachments: [],
+        text: `TRANSPORT_SMOKE_PROBE_${stamp}. Reply with exactly TRANSPORT_SMOKE_ACK_${stamp}.`,
+        threadId: selectedThreadId
+      }),
+      headers: {
+        ...surfaceHeaders(accessToken),
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+    metrics.push(summarizeMetric("send", send));
+
+    const release = await measuredJson(new URL("/api/codex-app-server/control", baseUrl), {
+      body: JSON.stringify({
+        action: "release",
+        reason: "transport_smoke_cleanup",
+        threadId: selectedThreadId
+      }),
+      headers: {
+        ...surfaceHeaders(accessToken),
+        "Content-Type": "application/json"
+      },
+      method: "POST"
+    });
+    metrics.push(summarizeMetric("release", release));
+  }
+
+  const summary = {
+    metrics,
+    selectedProjectCwd,
+    selectedThreadId,
+    surface: options.surface
+  };
+
+  if (options.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+
+  for (const metric of metrics) {
+    console.log(`[${options.surface}] ${metric.name} elapsedMs=${metric.elapsedMs} bytes=${metric.bytes} status=${metric.status}`);
+  }
+  if (selectedThreadId) {
+    console.log(`[${options.surface}] selectedThreadId=${selectedThreadId}`);
+  }
+}
+
+main().catch((error) => {
+  console.error(error?.message || String(error));
+  process.exit(1);
+});

package/src/bin/probe-codex-app-server-write.mjs

@@ -0,0 +1,36 @@
+import { mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { createCodexAppServerBridge } from "../lib/codex-app-server-client.mjs";
+
+const cwd = process.argv[2] || path.join(tmpdir(), "dextunnel-app-server-write-probe");
+const bridge = createCodexAppServerBridge();
+
+try {
+  await mkdir(cwd, { recursive: true });
+  const result = await bridge.sendText({
+    cwd,
+    text: "Reply with REMOTE_WRITE_OK only.",
+    createThreadIfMissing: true,
+    timeoutMs: 45000
+  });
+
+  console.log(
+    JSON.stringify(
+      {
+        ok: true,
+        cwd,
+        mode: result.mode,
+        threadId: result.thread.id,
+        turnId: result.turn.id,
+        turnStatus: result.turn.status,
+        preview: result.snapshot.transcript.slice(-6)
+      },
+      null,
+      2
+    )
+  );
+} finally {
+  await bridge.dispose();
+}

package/src/bin/probe-codex-app-server.mjs

@@ -0,0 +1,30 @@
+import { createCodexAppServerBridge, mapThreadToCompanionSnapshot } from "../lib/codex-app-server-client.mjs";
+
+const cwd = process.argv[2] || process.cwd();
+const bridge = createCodexAppServerBridge();
+
+try {
+  const thread = await bridge.getLatestThreadForCwd(cwd);
+
+  if (!thread) {
+    console.log(JSON.stringify({ cwd, found: false }, null, 2));
+    process.exit(0);
+  }
+
+  const snapshot = mapThreadToCompanionSnapshot(thread);
+  console.log(
+    JSON.stringify(
+      {
+        found: true,
+        cwd,
+        thread: snapshot.thread,
+        transcriptCount: snapshot.transcript.length,
+        preview: snapshot.transcript.slice(-8)
+      },
+      null,
+      2
+    )
+  );
+} finally {
+  await bridge.dispose();
+}

package/src/lib/agent-room-context.mjs

@@ -0,0 +1,54 @@
+function formatTimestampLabel(value) {
+  const date = new Date(value || 0);
+  if (Number.isNaN(date.getTime())) {
+    return "";
+  }
+  return date.toISOString();
+}
+
+function formatContextEntries(entries = [], limit = 10, { trimTopicText }) {
+  return entries
+    .slice(-limit)
+    .map((entry) => {
+      const label = entry?.participant?.label || entry?.participantId || entry?.origin || entry?.lane || entry?.role || "voice";
+      const text = trimTopicText(entry?.text || "", 280);
+      const timestamp = entry?.timestamp ? formatTimestampLabel(entry.timestamp) : "";
+      return `- ${timestamp ? `[${timestamp}] ` : ""}${label}: ${text}`;
+    })
+    .join("\n");
+}
+
+export function createAgentRoomContextBuilder({
+  buildSelectedChannel,
+  decorateSnapshot,
+  nowIso,
+  trimTopicText
+}) {
+  function buildAgentRoomContextMarkdown({ roomState, snapshot, threadId }) {
+    const selectedSnapshot = snapshot ? decorateSnapshot(snapshot) : null;
+    const channel = selectedSnapshot?.channel || buildSelectedChannel(selectedSnapshot);
+    const mainEntries = selectedSnapshot?.transcript || [];
+    const roomEntries = roomState?.messages || [];
+
+    return [
+      "# Dextunnel Council Room Context",
+      "",
+      `generated_at: ${nowIso()}`,
+      `thread_id: ${threadId || channel.channelId || ""}`,
+      `server: ${channel.serverLabel || ""}`,
+      `channel: ${channel.channelSlug || ""}`,
+      `topic: ${channel.topic || ""}`,
+      "",
+      "## Main Codex thread excerpt",
+      formatContextEntries(mainEntries, 10, { trimTopicText }) || "- No main-thread transcript available.",
+      "",
+      "## Council room transcript",
+      formatContextEntries(roomEntries, 20, { trimTopicText }) || "- No prior council-room messages.",
+      ""
+    ].join("\n");
+  }
+
+  return {
+    buildAgentRoomContextMarkdown
+  };
+}