@coworker-jp/aidr 0.0.1

package/src/toml-merge.mjs

@@ -0,0 +1,167 @@
+// Line-based TOML merger for Codex's ~/.codex/config.toml feature flag.
+// Codex requires `[features] codex_hooks = true` to activate hook dispatch.
+// Users may already have their own config (model settings, other features), so
+// we must merge rather than overwrite.
+//
+// Scope: *only* handles a single key inside a single section. No full TOML
+// parser, no external deps. Preserves comments, blank lines, ordering, and
+// other sections exactly.
+
+const SECTION = "features";
+const KEY = "codex_hooks";
+const VALUE = "true";
+
+// Match a section header line: optional leading whitespace, `[name]`, optional trailing comment.
+function sectionHeader(name) {
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^\\s*\\[\\s*${escaped}\\s*\\](?:\\s*#.*)?$`);
+}
+
+// Match any section header (used to find section boundaries).
+const ANY_SECTION_RE = /^\s*\[\s*[^\]]+\s*\](?:\s*#.*)?$/;
+
+// Match `key = value` with optional trailing comment; capture the value token.
+function keyAssignment(key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`^(\\s*${escaped}\\s*=\\s*)([^#\\n]*?)(\\s*(?:#.*)?)$`);
+}
+
+// Detect obvious malformed TOML so we fail closed instead of silently corrupting.
+// Only catches the most common case (unclosed bracket on a section header line) —
+// full TOML validation is out of scope.
+function validate(text) {
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // Strip inline string content before looking for unbalanced brackets.
+    const stripped = line.replace(/"[^"]*"/g, "").replace(/'[^']*'/g, "");
+    // A line that starts with `[` must contain a closing `]` before any `#`.
+    if (/^\s*\[/.test(stripped)) {
+      const preComment = stripped.split("#")[0];
+      const opens = (preComment.match(/\[/g) || []).length;
+      const closes = (preComment.match(/\]/g) || []).length;
+      if (opens !== closes) {
+        throw new Error(`malformed TOML at line ${i + 1}: unbalanced brackets (${line.trim()})`);
+      }
+    }
+  }
+}
+
+function findSectionRange(lines, section) {
+  const headerRe = sectionHeader(section);
+  let start = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (headerRe.test(lines[i])) { start = i; break; }
+  }
+  if (start === -1) return null;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (ANY_SECTION_RE.test(lines[i])) { end = i; break; }
+  }
+  return { start, end };
+}
+
+// Merge `[features] codex_hooks = true` into the given TOML text, preserving
+// everything else. Idempotent: re-running on an already-merged file is a no-op.
+export function mergeCodexHookFeature(text) {
+  const input = text ?? "";
+  if (input !== "") validate(input);
+
+  // Empty file / whitespace-only: write a fresh minimal TOML.
+  if (input.trim() === "") {
+    return `[${SECTION}]\n${KEY} = ${VALUE}\n`;
+  }
+
+  const lines = input.split("\n");
+  // Preserve final newline state — JSON.stringify-style: if original ended with
+  // "\n", .split gives a trailing "" element we'll keep and rejoin with.
+  const range = findSectionRange(lines, SECTION);
+  const assignRe = keyAssignment(KEY);
+
+  if (range) {
+    // Section exists — look for the key inside it.
+    for (let i = range.start + 1; i < range.end; i++) {
+      const m = assignRe.exec(lines[i]);
+      if (m) {
+        const currentValue = m[2].trim();
+        if (currentValue === VALUE) return input; // already correct, no-op
+        lines[i] = `${m[1]}${VALUE}${m[3]}`;      // overwrite `false` / other
+        return lines.join("\n");
+      }
+    }
+    // Key absent — insert right after the section header (before any subkeys),
+    // so the new line doesn't get buried under a long section.
+    lines.splice(range.start + 1, 0, `${KEY} = ${VALUE}`);
+    return lines.join("\n");
+  }
+
+  // Section absent — append a fresh `[features]` block at EOF. Ensure at least
+  // one blank line separates it from prior content for readability.
+  const needsLeadingBlank = input.length > 0 && !input.endsWith("\n\n");
+  const prefix = input.endsWith("\n") ? "" : "\n";
+  const spacer = needsLeadingBlank ? "\n" : "";
+  return `${input}${prefix}${spacer}[${SECTION}]\n${KEY} = ${VALUE}\n`;
+}
+
+// Reverse of mergeCodexHookFeature: strip our `codex_hooks = true` line.
+// - Removes the key line.
+// - Removes an empty `[features]` section if our line was the only content.
+// Returns { text, empty } — empty=true means the TOML is now effectively blank
+// so the caller can delete the file entirely.
+export function unmergeCodexHookFeature(text) {
+  const input = text ?? "";
+  if (input.trim() === "") return { text: "", empty: true };
+  validate(input);
+
+  const lines = input.split("\n");
+  const range = findSectionRange(lines, SECTION);
+  if (!range) {
+    // No [features] section — nothing to strip.
+    return { text: input, empty: input.trim() === "" };
+  }
+
+  const assignRe = keyAssignment(KEY);
+  let removedIdx = -1;
+  for (let i = range.start + 1; i < range.end; i++) {
+    if (assignRe.test(lines[i])) { removedIdx = i; break; }
+  }
+
+  if (removedIdx === -1) {
+    return { text: input, empty: input.trim() === "" };
+  }
+
+  lines.splice(removedIdx, 1);
+
+  // Re-evaluate the section bounds after removal.
+  const newRange = findSectionRange(lines, SECTION);
+  if (newRange) {
+    let hasContent = false;
+    for (let i = newRange.start + 1; i < newRange.end; i++) {
+      const line = lines[i];
+      if (line.trim() === "" || /^\s*#/.test(line)) continue;
+      hasContent = true;
+      break;
+    }
+    if (!hasContent) {
+      // Remove the header line and any immediately trailing blank lines that
+      // were separating this section from the next — otherwise leave them
+      // alone.
+      let deleteCount = newRange.end - newRange.start;
+      while (
+        newRange.start + deleteCount < lines.length &&
+        lines[newRange.start + deleteCount].trim() === ""
+      ) {
+        deleteCount++;
+        // Stop before eating a separator that leads into another section.
+        if (
+          newRange.start + deleteCount < lines.length &&
+          ANY_SECTION_RE.test(lines[newRange.start + deleteCount])
+        ) break;
+      }
+      lines.splice(newRange.start, deleteCount);
+    }
+  }
+
+  const result = lines.join("\n");
+  return { text: result, empty: result.trim() === "" };
+}

package/src/verify.mjs

@@ -0,0 +1,51 @@
+// POST /verify — access key server-side validation.
+//
+// `env` (dev|prod) selects the verify endpoint / S3 bucket / download URL.
+// `plan` is the subscription tier (standard | pro | trial) returned by the
+// verify API — do NOT conflate the two.
+
+const ENDPOINTS = {
+  prod: "https://pytd2jd5p7.execute-api.ap-northeast-1.amazonaws.com",
+  dev: "https://zf1kjdpi6a.execute-api.ap-northeast-1.amazonaws.com",
+};
+
+export function verifyEndpoint(env = "prod") {
+  const base = ENDPOINTS[env] || ENDPOINTS.prod;
+  return `${base}/verify`;
+}
+
+export function downloadBase(env = "prod") {
+  const base = ENDPOINTS[env] || ENDPOINTS.prod;
+  return `${base}/download`;
+}
+
+export async function verifyKey(accessKey, env = "prod") {
+  const url = verifyEndpoint(env);
+  let res;
+  try {
+    res = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ access_key: accessKey }),
+    });
+  } catch (e) {
+    throw new Error(`verify request failed: ${e.message}`);
+  }
+  if (!res.ok) {
+    throw new Error(`verify returned HTTP ${res.status}`);
+  }
+  const body = await res.json().catch(() => ({}));
+  if (body.status !== "active") {
+    throw new Error(`access key status is '${body.status || "unknown"}' (expected 'active')`);
+  }
+  return {
+    status: body.status,
+    plan: body.plan || "standard",
+    expires_at: body.expires_at || null,
+  };
+}
+
+export function maskKey(accessKey) {
+  if (!accessKey || accessKey.length < 12) return "***";
+  return `${accessKey.slice(0, 6)}...${accessKey.slice(-4)}`;
+}