quadwork 1.10.1 → 1.11.1

package/server/__tests__/bridge-auto-stop-guard.test.js

@@ -0,0 +1,134 @@
+/**
+ * #542 — Verify bridge auto-stop fires only on the transition from
+ * incomplete → complete, not on every polling tick.
+ *
+ * Since autoStopPollingTick is tightly coupled to HTTP calls, we test
+ * the guard logic by reading server/index.js and verifying the code
+ * structure, then simulating the guard in isolation.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const SERVER_PATH = path.join(__dirname, "..", "index.js");
+const src = fs.readFileSync(SERVER_PATH, "utf-8");
+
+// ---------------------------------------------------------------------------
+// 1. Code-structure assertions — verify the guard exists in source
+// ---------------------------------------------------------------------------
+
+describe("#542 bridge auto-stop transition guard (code analysis)", () => {
+  test("autoStopBridges in polling path is guarded by prev.complete check", () => {
+    // Find the autoStopPollingTick function body
+    const fnStart = src.indexOf("async function autoStopPollingTick()");
+    expect(fnStart).toBeGreaterThan(-1);
+
+    // Extract the function body (up to the next top-level function or setInterval)
+    const fnBody = src.slice(fnStart, src.indexOf("setInterval(autoStopPollingTick"));
+
+    // The autoStopBridges call must be guarded by a prev.complete check
+    const stopIdx = fnBody.indexOf("autoStopBridges(project.id");
+    expect(stopIdx).toBeGreaterThan(-1);
+
+    // Look at the surrounding context — the guard should appear before the call
+    const guardRegion = fnBody.slice(Math.max(0, stopIdx - 200), stopIdx);
+    expect(guardRegion).toMatch(/!prev\.complete/);
+  });
+
+  test("autoStartBridges in polling path is still transition-guarded", () => {
+    const fnStart = src.indexOf("async function autoStopPollingTick()");
+    const fnBody = src.slice(fnStart, src.indexOf("setInterval(autoStopPollingTick"));
+    const startIdx = fnBody.indexOf("autoStartBridges(");
+    expect(startIdx).toBeGreaterThan(-1);
+
+    const guardRegion = fnBody.slice(Math.max(0, startIdx - 200), startIdx);
+    expect(guardRegion).toMatch(/isNewBatch/);
+  });
+
+  test("_bridgeBatchPrev.set is called before the guard checks", () => {
+    const fnStart = src.indexOf("async function autoStopPollingTick()");
+    const fnBody = src.slice(fnStart, src.indexOf("setInterval(autoStopPollingTick"));
+
+    const setIdx = fnBody.indexOf("_bridgeBatchPrev.set(");
+    const stopIdx = fnBody.indexOf("autoStopBridges(project.id");
+    expect(setIdx).toBeGreaterThan(-1);
+    expect(setIdx).toBeLessThan(stopIdx);
+  });
+
+  test("autoStopBridges in sendTriggerMessage is guarded by prev.complete check", () => {
+    const fnStart = src.indexOf("async function sendTriggerMessage(");
+    expect(fnStart).toBeGreaterThan(-1);
+
+    // Extract until the next top-level function
+    const fnBody = src.slice(fnStart, fnStart + 2000);
+
+    const stopIdx = fnBody.indexOf("autoStopBridges(");
+    expect(stopIdx).toBeGreaterThan(-1);
+
+    // The guard should appear before the call
+    const guardRegion = fnBody.slice(Math.max(0, stopIdx - 300), stopIdx);
+    expect(guardRegion).toMatch(/!prev\.complete/);
+  });
+
+  test("sendTriggerMessage updates _bridgeBatchPrev before the guard", () => {
+    const fnStart = src.indexOf("async function sendTriggerMessage(");
+    const fnBody = src.slice(fnStart, fnStart + 2000);
+
+    const setIdx = fnBody.indexOf("_bridgeBatchPrev.set(");
+    const stopIdx = fnBody.indexOf("autoStopBridges(");
+    expect(setIdx).toBeGreaterThan(-1);
+    expect(setIdx).toBeLessThan(stopIdx);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 2. Guard-logic simulation — mirrors the if-condition in autoStopPollingTick
+// ---------------------------------------------------------------------------
+
+describe("#542 bridge auto-stop transition guard (logic simulation)", () => {
+  function shouldAutoStop(bp, prev) {
+    // Mirrors the production guard:
+    //   if (hasBridgeAuto && (!prev || !prev.complete)) { autoStopBridges(...) }
+    if (!(bp && bp.complete)) return false;
+    return !prev || !prev.complete;
+  }
+
+  test("fires on first tick when batch is already complete (no prev)", () => {
+    expect(shouldAutoStop({ complete: true }, undefined)).toBe(true);
+  });
+
+  test("fires on transition from incomplete to complete", () => {
+    expect(shouldAutoStop({ complete: true }, { complete: false, hasItems: true })).toBe(true);
+  });
+
+  test("does NOT fire on repeated complete ticks", () => {
+    expect(shouldAutoStop({ complete: true }, { complete: true, hasItems: true })).toBe(false);
+  });
+
+  test("does NOT fire when batch is not complete", () => {
+    expect(shouldAutoStop({ complete: false }, undefined)).toBe(false);
+    expect(shouldAutoStop({ complete: false }, { complete: false })).toBe(false);
+  });
+
+  test("manually restarted bridges survive repeated complete ticks", () => {
+    // Simulates: batch completes → tick 1 stops bridges → operator restarts →
+    // tick 2 should NOT stop again because prev.complete is already true
+    const tick1 = shouldAutoStop({ complete: true }, undefined);
+    expect(tick1).toBe(true); // first transition fires
+
+    // After tick 1, prev = { complete: true }
+    const tick2 = shouldAutoStop({ complete: true }, { complete: true });
+    expect(tick2).toBe(false); // no repeated stop
+  });
+
+  test("auto-stop fires again for a new batch cycle", () => {
+    // batch 1 completes → new batch starts → new batch completes
+    const batch1Complete = shouldAutoStop({ complete: true }, { complete: false });
+    expect(batch1Complete).toBe(true);
+
+    // new batch is in progress (prev was complete from batch 1)
+    // then new batch completes
+    const batch2Complete = shouldAutoStop({ complete: true }, { complete: false });
+    expect(batch2Complete).toBe(true);
+  });
+});

package/server/__tests__/scrub-secrets.test.js

@@ -0,0 +1,234 @@
+/**
+ * #545: QA verification for #538 PTY scrollback secret scrubbing.
+ *
+ * Tests the production scrubSecrets / scrubScrollback from server/scrub-secrets.js:
+ *  - Redact secrets correctly (SECRET_NAME, API key prefixes, Bearer)
+ *  - Pass through normal terminal output unchanged
+ *  - Preserve ANSI escape codes on non-secret lines
+ *  - Handle edge cases (empty input, very long lines, rapid multi-line output)
+ *
+ * Integration-level checklist items (resize, reconnect/replay flow,
+ * multi-agent isolation, two-tab behavior) are verified by code-path
+ * analysis in the PR description — they depend on WS + PTY runtime
+ * that cannot be unit-tested without a full server harness.
+ */
+
+const { scrubSecrets, scrubScrollback, _REDACTED } = require("../scrub-secrets");
+
+// ---- Tests ----
+
+const assert = require("assert");
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`  PASS  ${name}`);
+  } catch (e) {
+    failed++;
+    console.error(`  FAIL  ${name}`);
+    console.error(`        ${e.message}`);
+  }
+}
+
+console.log("\n#545 QA — scrubSecrets / scrubScrollback (production module)\n");
+
+// --- 1. Secret redaction (true positives) ---
+
+test("redacts ANTHROPIC_API_KEY=value", () => {
+  const input = "ANTHROPIC_API_KEY=sk-ant-api03-xxxxxxxxxxxx";
+  const out = scrubSecrets(input);
+  assert(!out.includes("sk-ant-api03"), `got: ${out}`);
+  assert(out.includes(_REDACTED));
+});
+
+test("redacts DB_PASSWORD: hunter2", () => {
+  const out = scrubSecrets("DB_PASSWORD: hunter2");
+  assert(!out.includes("hunter2"), `got: ${out}`);
+});
+
+test("redacts GITHUB_TOKEN=ghp_...", () => {
+  const token = "ghp_" + "A".repeat(36);
+  const out = scrubSecrets(`export GITHUB_TOKEN=${token}`);
+  assert(!out.includes(token), `got: ${out}`);
+});
+
+test("redacts Bearer token header", () => {
+  const out = scrubSecrets("Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.payload.sig");
+  assert(!out.includes("eyJhbG"), `got: ${out}`);
+  assert(out.includes(_REDACTED));
+});
+
+test("redacts standalone Bearer (no Authorization: prefix)", () => {
+  const out = scrubSecrets("curl -H 'Bearer eyJhbGciOiJIUzI1NiJ9.xxxxxxxxxxxx'");
+  assert(!out.includes("eyJhbG"), `got: ${out}`);
+  assert(out.includes(`Bearer ${_REDACTED}`));
+});
+
+test("redacts sk- OpenAI key inline", () => {
+  const key = "sk-" + "a".repeat(48);
+  const out = scrubSecrets(`Using key ${key} for request`);
+  assert(!out.includes(key), `got: ${out}`);
+});
+
+test("redacts Slack xoxb token", () => {
+  const token = "xoxb-" + "1234567890-" + "A".repeat(20);
+  const out = scrubSecrets(`SLACK_TOKEN=${token}`);
+  assert(!out.includes(token), `got: ${out}`);
+});
+
+// --- 2. Normal output passes through unchanged ---
+
+test("preserves plain text", () => {
+  const input = "Hello, world! This is normal output.";
+  assert.strictEqual(scrubSecrets(input), input);
+});
+
+test("preserves npm install output", () => {
+  const input = "added 1423 packages in 45s\n182 packages are looking for funding";
+  assert.strictEqual(scrubSecrets(input), input);
+});
+
+test("preserves git clone output", () => {
+  const input = "Cloning into 'repo'...\nremote: Enumerating objects: 1234, done.\nReceiving objects: 100% (1234/1234)";
+  assert.strictEqual(scrubSecrets(input), input);
+});
+
+test("preserves test runner output", () => {
+  const input = "Tests: 42 passed, 42 total\nTime: 3.456 s";
+  assert.strictEqual(scrubSecrets(input), input);
+});
+
+test("preserves JSON output without secrets", () => {
+  const input = '{"status":"ok","count":42,"items":["a","b","c"]}';
+  assert.strictEqual(scrubSecrets(input), input);
+});
+
+// --- 3. ANSI escape code handling ---
+
+test("preserves ANSI colors on non-secret lines", () => {
+  const input = "\x1b[32m✓\x1b[0m test passed";
+  assert.strictEqual(scrubSecrets(input), input);
+});
+
+test("redacts secret even inside ANSI-styled line", () => {
+  const input = "\x1b[33mAPI_KEY=\x1b[31msecretvalue123\x1b[0m";
+  const out = scrubSecrets(input);
+  assert(!out.includes("secretvalue123"), `got: ${out}`);
+  assert(out.includes(_REDACTED));
+});
+
+test("ANSI bold output without secrets passes through", () => {
+  const input = "\x1b[1mBuilding project...\x1b[0m\nCompiled successfully.";
+  assert.strictEqual(scrubSecrets(input), input);
+});
+
+// --- 4. Edge cases ---
+
+test("handles empty string", () => {
+  assert.strictEqual(scrubSecrets(""), "");
+});
+
+test("handles null/undefined", () => {
+  assert.strictEqual(scrubSecrets(null), null);
+  assert.strictEqual(scrubSecrets(undefined), undefined);
+});
+
+test("handles very long line (>1000 chars) without secrets", () => {
+  const longLine = "x".repeat(2000);
+  assert.strictEqual(scrubSecrets(longLine), longLine);
+});
+
+test("handles very long line with embedded secret", () => {
+  const prefix = "a".repeat(500);
+  const suffix = "b".repeat(500);
+  const key = "sk-" + "c".repeat(48);
+  const input = `${prefix} ${key} ${suffix}`;
+  const out = scrubSecrets(input);
+  assert(!out.includes(key), `key should be redacted`);
+});
+
+test("handles rapid multi-line output (100 lines)", () => {
+  const lines = Array.from({ length: 100 }, (_, i) => `line ${i}: output data here`);
+  const input = lines.join("\n");
+  assert.strictEqual(scrubSecrets(input), input);
+});
+
+test("handles multi-line with mixed secrets and normal output", () => {
+  const input = [
+    "Starting deploy...",
+    "AWS_SECRET_ACCESS_KEY=AKIAIOSFODNN7EXAMPLE",
+    "Uploading artifacts...",
+    "Bearer eyJhbGciOiJIUzI1NiJ9.xxxxxxxxxxxx",
+    "Deploy complete!",
+  ].join("\n");
+  const out = scrubSecrets(input);
+  assert(out.includes("Starting deploy..."));
+  assert(out.includes("Uploading artifacts..."));
+  assert(out.includes("Deploy complete!"));
+  assert(!out.includes("AKIAIOSFODNN7EXAMPLE"));
+  assert(!out.includes("eyJhbGci"));
+});
+
+// --- 5. scrubScrollback (Buffer handling) ---
+
+test("scrubScrollback returns Buffer", () => {
+  const buf = Buffer.from("SOME_SECRET_KEY=abc123\nnormal line");
+  const out = scrubScrollback(buf);
+  assert(Buffer.isBuffer(out), "should return a Buffer");
+  assert(!out.toString().includes("abc123"));
+});
+
+test("scrubScrollback handles empty buffer", () => {
+  const buf = Buffer.alloc(0);
+  const out = scrubScrollback(buf);
+  assert(Buffer.isBuffer(out));
+  assert.strictEqual(out.length, 0);
+});
+
+test("scrubScrollback handles null", () => {
+  assert.strictEqual(scrubScrollback(null), null);
+});
+
+test("scrubScrollback preserves non-secret content", () => {
+  const content = "Hello world\nBuild succeeded\n42 tests passed";
+  const buf = Buffer.from(content);
+  const out = scrubScrollback(buf);
+  assert.strictEqual(out.toString(), content);
+});
+
+// --- 6. Integration path verification ---
+// These tests verify that server/index.js imports from the same module
+// we're testing, ensuring no copy-paste drift.
+
+test("server/index.js imports scrubSecrets from scrub-secrets.js", () => {
+  const serverSource = require("fs").readFileSync(
+    require("path").join(__dirname, "..", "index.js"), "utf-8"
+  );
+  assert(
+    serverSource.includes('require("./scrub-secrets")') ||
+    serverSource.includes("require('./scrub-secrets')"),
+    "server/index.js must import from ./scrub-secrets"
+  );
+});
+
+test("server/index.js uses scrubSecrets in PTY data handler", () => {
+  const serverSource = require("fs").readFileSync(
+    require("path").join(__dirname, "..", "index.js"), "utf-8"
+  );
+  assert(serverSource.includes("scrubSecrets(data)"), "live PTY path must call scrubSecrets");
+});
+
+test("server/index.js uses scrubScrollback in replay handler", () => {
+  const serverSource = require("fs").readFileSync(
+    require("path").join(__dirname, "..", "index.js"), "utf-8"
+  );
+  assert(serverSource.includes("scrubScrollback(session.scrollback)"), "replay path must call scrubScrollback");
+});
+
+// --- Summary ---
+
+console.log(`\nResults: ${passed} passed, ${failed} failed, ${passed + failed} total\n`);
+process.exit(failed > 0 ? 1 : 0);

package/server/__tests__/v1110-security-qa.test.js

@@ -0,0 +1,312 @@
+/**
+ * #549: QA verification for v1.11.0 security hardening.
+ *
+ * Covers PRs #543, #546, #547, #548:
+ *  - #543: execFileSync refactor (no shell interpolation)
+ *  - #546: Next.js upgrade to 16.2.4
+ *  - #547: File/directory permission hardening (0o700/0o600)
+ *  - #548: WebSocket resize input validation
+ *
+ * Integration-level items (wizard flow, browser open, AC start,
+ * multi-tab WS) require a live server and are verified by code-path
+ * analysis in the PR description.
+ */
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`  PASS  ${name}`);
+  } catch (e) {
+    failed++;
+    console.error(`  FAIL  ${name}`);
+    console.error(`        ${e.message}`);
+  }
+}
+
+const ROOT = path.resolve(__dirname, "../..");
+const SERVER_DIR = path.resolve(__dirname, "..");
+
+console.log("\n#549 QA — v1.11.0 security hardening\n");
+
+// ============================================================================
+// PR #543 — execFileSync refactor
+// ============================================================================
+
+console.log("--- PR #543: execFileSync refactor ---\n");
+
+test("bin/quadwork.js has no execSync import", () => {
+  const src = fs.readFileSync(path.join(ROOT, "bin/quadwork.js"), "utf-8");
+  // execFileSync is OK, execSync is not
+  const lines = src.split("\n");
+  const badLines = lines.filter(
+    (l) => /\bexecSync\b/.test(l) && !/execFileSync/.test(l)
+  );
+  assert.strictEqual(badLines.length, 0, `Found execSync: ${badLines[0]}`);
+});
+
+test("server/index.js has no execSync import", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "index.js"), "utf-8");
+  const lines = src.split("\n");
+  const badLines = lines.filter(
+    (l) => /\bexecSync\b/.test(l) && !/execFileSync/.test(l)
+  );
+  assert.strictEqual(badLines.length, 0, `Found execSync: ${badLines[0]}`);
+});
+
+test("server/install-agentchattr.js has no execSync import", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "install-agentchattr.js"), "utf-8");
+  const lines = src.split("\n");
+  const badLines = lines.filter(
+    (l) => /\bexecSync\b/.test(l) && !/execFileSync/.test(l)
+  );
+  assert.strictEqual(badLines.length, 0, `Found execSync: ${badLines[0]}`);
+});
+
+test("scripts/e2e-per-project.js has no execSync import", () => {
+  const src = fs.readFileSync(path.join(ROOT, "scripts/e2e-per-project.js"), "utf-8");
+  const lines = src.split("\n");
+  const badLines = lines.filter(
+    (l) => /\bexecSync\b/.test(l) && !/execFileSync/.test(l)
+  );
+  assert.strictEqual(badLines.length, 0, `Found execSync: ${badLines[0]}`);
+});
+
+test("bin/quadwork.js run() uses execFileSync with array args", () => {
+  const src = fs.readFileSync(path.join(ROOT, "bin/quadwork.js"), "utf-8");
+  assert(src.includes("function run(cmd, args = [], opts = {})"), "run() signature should accept array args");
+  assert(src.includes("execFileSync(cmd, args,"), "run() should call execFileSync with cmd, args");
+});
+
+test("bin/quadwork.js which() uses run() with array args", () => {
+  const src = fs.readFileSync(path.join(ROOT, "bin/quadwork.js"), "utf-8");
+  assert(src.includes('run("which", [cmd])'), "which() should use array args");
+});
+
+test("bin/quadwork.js browser-open uses execFileSync (no shell)", () => {
+  const src = fs.readFileSync(path.join(ROOT, "bin/quadwork.js"), "utf-8");
+  // Windows path: cmd /c start
+  assert(src.includes('execFileSync("cmd", ["/c", "start"'), "Windows browser open should use execFileSync");
+  // macOS/Linux: open or xdg-open
+  assert(src.includes('execFileSync(process.platform === "darwin" ? "open" : "xdg-open"'), "macOS/Linux browser open should use execFileSync");
+});
+
+test("server/index.js isCliInstalled uses execFileSync", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "index.js"), "utf-8");
+  assert(src.includes('execFileSync("which", [cmd]'), "isCliInstalled should use execFileSync");
+});
+
+test("server/index.js killProcessOnPort uses execFileSync", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "index.js"), "utf-8");
+  assert(src.includes('execFileSync("lsof", ["-ti"'), "killProcessOnPort should use execFileSync");
+});
+
+// ============================================================================
+// PR #546 — Next.js upgrade
+// ============================================================================
+
+console.log("\n--- PR #546: Next.js upgrade ---\n");
+
+test("package.json specifies Next.js >= 16.2.4 (not vulnerable 16.2.1-16.2.3)", () => {
+  const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, "package.json"), "utf-8"));
+  const nextVersion = pkg.dependencies?.next || "";
+  // Strip leading ^ or ~ for comparison
+  const bare = nextVersion.replace(/^[~^]+/, "");
+  const [major, minor, patch] = bare.split(".").map(Number);
+  assert(
+    major > 16 || (major === 16 && minor > 2) || (major === 16 && minor === 2 && patch >= 4),
+    `Expected next >= 16.2.4, got ${nextVersion}`
+  );
+});
+
+test("package-lock.json has Next.js 16.2.4+ (resolved version)", () => {
+  const lock = JSON.parse(fs.readFileSync(path.join(ROOT, "package-lock.json"), "utf-8"));
+  const nextPkg = lock.packages?.["node_modules/next"];
+  assert(nextPkg, "next should be in package-lock.json");
+  const version = nextPkg.version;
+  const [major, minor, patch] = version.split(".").map(Number);
+  assert(
+    major > 16 || (major === 16 && minor > 2) || (major === 16 && minor === 2 && patch >= 4),
+    `Expected >= 16.2.4, got ${version}`
+  );
+});
+
+test("next build succeeds (runs build from scratch)", () => {
+  // Actually run the build to verify Next.js 16.2.4 works.
+  const { execFileSync } = require("child_process");
+  try {
+    execFileSync("npx", ["next", "build"], {
+      cwd: ROOT,
+      stdio: "pipe",
+      timeout: 120000,
+    });
+  } catch (e) {
+    assert.fail(`next build failed: ${e.stderr?.toString().slice(-500) || e.message}`);
+  }
+  const outIndex = path.join(ROOT, "out", "index.html");
+  assert(fs.existsSync(outIndex), "out/index.html should exist after build");
+});
+
+// ============================================================================
+// PR #547 — File/directory permission hardening
+// ============================================================================
+
+console.log("\n--- PR #547: File/directory permission hardening ---\n");
+
+test("server/config.js exports ensureSecureDir", () => {
+  const config = require(path.join(SERVER_DIR, "config.js"));
+  assert(typeof config.ensureSecureDir === "function", "ensureSecureDir should be exported");
+});
+
+test("server/config.js exports writeSecureFile", () => {
+  const config = require(path.join(SERVER_DIR, "config.js"));
+  assert(typeof config.writeSecureFile === "function", "writeSecureFile should be exported");
+});
+
+test("server/config.js exports writeConfig", () => {
+  const config = require(path.join(SERVER_DIR, "config.js"));
+  assert(typeof config.writeConfig === "function", "writeConfig should be exported");
+});
+
+test("ensureSecureDir creates dir with 0o700", () => {
+  const { ensureSecureDir } = require(path.join(SERVER_DIR, "config.js"));
+  const tmpDir = path.join(require("os").tmpdir(), `qw-qa-test-${Date.now()}`);
+  try {
+    ensureSecureDir(tmpDir);
+    const stat = fs.statSync(tmpDir);
+    assert(stat.isDirectory(), "should be a directory");
+    assert.strictEqual(stat.mode & 0o777, 0o700, `expected 0o700, got ${(stat.mode & 0o777).toString(8)}`);
+  } finally {
+    try { fs.rmdirSync(tmpDir); } catch {}
+  }
+});
+
+test("writeSecureFile creates file with 0o600", () => {
+  const { writeSecureFile } = require(path.join(SERVER_DIR, "config.js"));
+  const tmpFile = path.join(require("os").tmpdir(), `qw-qa-test-${Date.now()}.txt`);
+  try {
+    writeSecureFile(tmpFile, "test content");
+    const stat = fs.statSync(tmpFile);
+    assert(stat.isFile(), "should be a file");
+    assert.strictEqual(stat.mode & 0o777, 0o600, `expected 0o600, got ${(stat.mode & 0o777).toString(8)}`);
+    assert.strictEqual(fs.readFileSync(tmpFile, "utf-8"), "test content");
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch {}
+  }
+});
+
+test("server/index.js imports ensureSecureDir and writeSecureFile", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "index.js"), "utf-8");
+  assert(src.includes("ensureSecureDir"), "should import ensureSecureDir");
+  assert(src.includes("writeSecureFile"), "should import writeSecureFile");
+  assert(src.includes("writeConfig"), "should import writeConfig");
+});
+
+test("server/routes.js imports ensureSecureDir and writeSecureFile", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "routes.js"), "utf-8");
+  assert(src.includes("ensureSecureDir"), "should import ensureSecureDir");
+  assert(src.includes("writeSecureFile"), "should import writeSecureFile");
+  assert(src.includes("writeConfig"), "should import writeConfig");
+});
+
+test("no raw mkdirSync without mode in server files", () => {
+  const files = ["index.js", "routes.js", "config.js"];
+  for (const file of files) {
+    const src = fs.readFileSync(path.join(SERVER_DIR, file), "utf-8");
+    const lines = src.split("\n");
+    const badLines = lines.filter(
+      (l) =>
+        /fs\.mkdirSync\(/.test(l) &&
+        !l.includes("mode:") &&
+        !l.includes("ensureSecureDir") &&
+        !l.trim().startsWith("//")
+    );
+    assert.strictEqual(
+      badLines.length,
+      0,
+      `${file} has raw mkdirSync without mode: ${badLines[0]}`
+    );
+  }
+});
+
+test("bin/quadwork.js uses ensureSecureDir for directory creation", () => {
+  const src = fs.readFileSync(path.join(ROOT, "bin/quadwork.js"), "utf-8");
+  assert(src.includes("ensureSecureDir"), "bin/quadwork.js should use ensureSecureDir");
+});
+
+test("install-agentchattr.js uses mode: 0o700 for mkdirSync", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "install-agentchattr.js"), "utf-8");
+  const lines = src.split("\n");
+  const mkdirLines = lines.filter((l) => /fs\.mkdirSync\(/.test(l) && !l.trim().startsWith("//"));
+  for (const line of mkdirLines) {
+    assert(line.includes("mode: 0o700"), `Missing mode: 0o700 in: ${line.trim()}`);
+  }
+});
+
+test("install-agentchattr.js uses mode: 0o600 for writeFileSync (security-sensitive files)", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "install-agentchattr.js"), "utf-8");
+  const lines = src.split("\n");
+  const writeLines = lines.filter(
+    (l) =>
+      /fs\.writeFileSync\(/.test(l) &&
+      !l.trim().startsWith("//") &&
+      // CSS/JS patches are non-sensitive (cosmetic overrides to AC UI)
+      !l.includes("cssPath") &&
+      !l.includes("jsPath")
+  );
+  for (const line of writeLines) {
+    assert(line.includes("mode: 0o600"), `Missing mode: 0o600 in: ${line.trim()}`);
+  }
+});
+
+// ============================================================================
+// PR #548 — WebSocket resize validation
+// ============================================================================
+
+console.log("\n--- PR #548: WebSocket resize validation ---\n");
+
+test("server/index.js has typeof number check for resize cols", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "index.js"), "utf-8");
+  assert(src.includes('typeof parsed.cols === "number"'), "should check typeof cols");
+});
+
+test("server/index.js has typeof number check for resize rows", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "index.js"), "utf-8");
+  assert(src.includes('typeof parsed.rows === "number"'), "should check typeof rows");
+});
+
+test("server/index.js validates Number.isFinite for resize", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "index.js"), "utf-8");
+  assert(src.includes("Number.isFinite(parsed.cols)"), "should validate isFinite for cols");
+  assert(src.includes("Number.isFinite(parsed.rows)"), "should validate isFinite for rows");
+});
+
+test("server/index.js bounds-checks resize to 1-500", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "index.js"), "utf-8");
+  assert(src.includes("parsed.cols >= 1"), "should lower-bound cols");
+  assert(src.includes("parsed.cols <= 500"), "should upper-bound cols");
+  assert(src.includes("parsed.rows >= 1"), "should lower-bound rows");
+  assert(src.includes("parsed.rows <= 500"), "should upper-bound rows");
+});
+
+test("resize validation is inside the resize handler block", () => {
+  const src = fs.readFileSync(path.join(SERVER_DIR, "index.js"), "utf-8");
+  // Verify the validation is between 'parsed.type === "resize"' and 'session.term.resize'
+  const resizeIdx = src.indexOf('parsed.type === "resize"');
+  const termResizeIdx = src.indexOf("session.term.resize(parsed.cols, parsed.rows)");
+  const typeofIdx = src.indexOf('typeof parsed.cols === "number"');
+  assert(resizeIdx > 0 && termResizeIdx > resizeIdx && typeofIdx > resizeIdx && typeofIdx < termResizeIdx,
+    "validation should be between resize type check and term.resize call");
+});
+
+// ============================================================================
+
+console.log(`\nResults: ${passed} passed, ${failed} failed, ${passed + failed} total\n`);
+process.exit(failed > 0 ? 1 : 0);