rewritable 0.3.0 → 0.6.0

package/src/publish-site.mjs

@@ -0,0 +1,85 @@
+// `rwa publish-site <file>` — copy a self-contained rewritable VERBATIM onto a
+// static site over scp, and print the live URL. The durable counterpart to
+// `rwa publish` (an ephemeral 24h service share). Because a rewritable is already
+// one self-contained .html, we publish the bytes unchanged — no hosted projection.
+//
+// Design: docs/plans/2026-06-06-ikangai-custom-publish-design.md.
+//
+// Online by design (the offline-first invariant of new/import does not apply to
+// a publish action). Failure surface mirrors publish.mjs: local file problems
+// reuse the CliError `file_error` codes (exit 2); missing config / bad name are
+// usage-class (exit 1); every transport failure is exit 4 (the bin labels exit 4
+// `publish_error`). The transport is injected ({execFile}) so tests run offline.
+
+import { readFile } from 'node:fs/promises';
+import { basename, resolve } from 'node:path';
+import { execFile as _execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { extractInlineDoc } from './seed.mjs';
+import { CliError } from './edit.mjs';
+
+// A publishable remote name: a plain filename ending in .html. basename() already
+// strips any directory, so this only has to reject names that survive basename and
+// could still inject shell tokens or be otherwise unsafe. No leading dot, no
+// path/space/metacharacters. (basename of '../../x.html' is 'x.html' — safe.)
+const SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*\.html$/;
+
+/**
+ * @param {string} filePath
+ * @param {{host?:string, path?:string, url?:string}} [opts] flag overrides
+ * @param {{execFile?:Function, env?:object}} [deps] injection seam for tests
+ * @returns {Promise<{name:string, url:string, remoteSpec:string}>}
+ * @throws {CliError} 2 file_error · 1 config_error/invalid_name · 4 transport
+ */
+export async function publishSite(filePath, opts = {}, deps = {}) {
+  const env = deps.env || process.env;
+  const execFile = deps.execFile || promisify(_execFile);
+
+  // 1. Read + validate — identical CliError file_error surface to publish.mjs.
+  let bytes;
+  try {
+    bytes = await readFile(filePath, 'utf8');
+  } catch (e) {
+    if (e && e.code === 'ENOENT') throw new CliError(2, 'not_found', { path: filePath });
+    throw new CliError(2, 'read_error', { path: filePath, errno: e && e.code, message: e && e.message });
+  }
+  try {
+    extractInlineDoc(bytes);
+  } catch {
+    throw new CliError(2, 'not_a_rewritable', { path: filePath });
+  }
+
+  // 2. Config: flags override env; nothing is baked into the package.
+  const host = opts.host || env.RWA_SITE_HOST;
+  const remotePath = opts.path || env.RWA_SITE_PATH;
+  const urlBase = opts.url || env.RWA_SITE_URL;
+  const missing = [];
+  if (!host) missing.push('RWA_SITE_HOST');
+  if (!remotePath) missing.push('RWA_SITE_PATH');
+  if (!urlBase) missing.push('RWA_SITE_URL');
+  if (missing.length) throw new CliError(1, 'config_error', { missing });
+
+  // 3. Remote name: basename only, then allowlist. Stops path traversal AND
+  //    shell-token injection at the same gate.
+  const name = basename(filePath);
+  if (!SAFE_NAME.test(name)) throw new CliError(1, 'invalid_name', { name });
+
+  // 4. Transport. execFile with an ARGUMENT ARRAY (never a shell string), and
+  //    `--` so a leading-dash path is not parsed as an scp option. The local
+  //    source is an ABSOLUTE path so scp never mis-reads an embedded ':' as a
+  //    remote host. scp overwrites the destination → republish is idempotent.
+  const remoteDir = remotePath.replace(/\/+$/, '');
+  const remoteSpec = `${host}:${remoteDir}/${name}`;
+  try {
+    await execFile('scp', ['--', resolve(filePath), remoteSpec]);
+  } catch (e) {
+    if (e && e.code === 'ENOENT') throw new CliError(4, 'scp_not_found', {});
+    throw new CliError(4, 'transport_error', {
+      stderr: (e && e.stderr) || '', code: e && e.code, message: e && e.message,
+    });
+  }
+
+  // 5. Result.
+  const url = `${urlBase.replace(/\/+$/, '')}/${name}`;
+  return { name, url, remoteSpec };
+}

package/src/publish.mjs

@@ -0,0 +1,98 @@
+// `rwa publish <file>` — publish a local rewritable to the service's snapshot
+// endpoint (`POST /publish`, service/server.js) and return the share URL.
+//
+// This is a THIN, honest client for an endpoint that already exists. The only
+// first-class path for "share MY locally-edited file": create with `rwa new`,
+// edit locally, `rwa publish`. The browser UIs (new.html / import.html) publish
+// a fresh or newly-converted container — never the user's edited bytes.
+//
+// Unlike `rwa new`/`rwa import`, this command is intentionally ONLINE; the
+// offline-first invariant does not apply to a publish action.
+//
+// Failure surface mirrors `rwa doc`/`rwa edit`: local file problems reuse the
+// CliError `file_error` codes (exit 2); every remote/network failure is exit 4
+// with an honest subcode (the bin labels exit 4 `publish_error`, not the shared
+// `agent_error`). The server's own `validateContainer` stays the single source
+// of validation truth — the local check here is only fail-fast.
+
+import { readFile } from 'node:fs/promises';
+import { extractInlineDoc } from './seed.mjs';
+import { CliError } from './edit.mjs';
+
+// Hardcoded production default. Overridable via --url (bin) or RWA_PUBLISH_URL.
+export const DEFAULT_PUBLISH_URL = 'https://rewritable.ikangai.com';
+
+/**
+ * Read, locally validate, and POST a rewritable's bytes to `<baseUrl>/publish`.
+ *
+ * @param {string} filePath
+ * @param {{ baseUrl?: string }} [opts] - baseUrl is the service ORIGIN; the
+ *   `/publish` path is appended here. Falls back to DEFAULT_PUBLISH_URL.
+ * @returns {Promise<{short:string, url:string, expiresAt:number}>} the server's
+ *   success object on 201.
+ * @throws {CliError} exit 2 (file_error: not_found/read_error/not_a_rewritable)
+ *   before any network call; exit 4 on every remote/network failure.
+ */
+export async function publishCmd(filePath, { baseUrl } = {}) {
+  // 1. Read — identical CliError file_error surface to doc.mjs.
+  let bytes;
+  try {
+    bytes = await readFile(filePath, 'utf8');
+  } catch (e) {
+    if (e && e.code === 'ENOENT') throw new CliError(2, 'not_found', { path: filePath });
+    throw new CliError(2, 'read_error', { path: filePath, errno: e && e.code, message: e && e.message });
+  }
+
+  // 2. Local fail-fast: is this even a rewritable? Same gate as `rwa doc`.
+  // The server re-validates authoritatively; this just avoids a wasted round
+  // trip and gives an offline-detectable error.
+  try {
+    extractInlineDoc(bytes);
+  } catch {
+    throw new CliError(2, 'not_a_rewritable', { path: filePath });
+  }
+
+  // 3. POST the raw bytes. The server reads the body raw and ignores
+  // content-type; text/html is the honest label for the payload.
+  const base = (baseUrl || DEFAULT_PUBLISH_URL).replace(/\/+$/, '');
+  const endpoint = `${base}/publish`;
+  let res;
+  try {
+    res = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'text/html; charset=utf-8' },
+      body: bytes,
+    });
+  } catch (e) {
+    throw new CliError(4, 'network_error', { url: endpoint, message: (e && e.message) || String(e) });
+  }
+
+  // Body may be empty or non-JSON on some error paths — parse defensively.
+  const text = await res.text();
+  let payload = null;
+  if (text) { try { payload = JSON.parse(text); } catch { payload = null; } }
+
+  if (res.status === 201) {
+    if (!payload || typeof payload.url !== 'string') {
+      throw new CliError(4, 'server_error', { status: 201, error: 'malformed_success_response' });
+    }
+    return payload; // { short, url, expiresAt }
+  }
+
+  // Map the server's error envelope to an honest subcode. Prefer the server's
+  // own `error` name when present, fall back to the HTTP status.
+  const errName = payload && typeof payload.error === 'string' ? payload.error : null;
+  if (res.status === 413 || errName === 'body_too_large') {
+    throw new CliError(4, 'body_too_large', { maxBytes: payload && payload.maxBytes });
+  }
+  if (res.status === 429 || errName === 'rate_limited') {
+    throw new CliError(4, 'rate_limited', { retryAfterSec: payload && payload.retryAfterSec });
+  }
+  if (res.status === 400) {
+    throw new CliError(4, 'validation_failed', { detail: payload && payload.detail, error: errName });
+  }
+  if (res.status >= 500) {
+    throw new CliError(4, 'server_error', { status: res.status, error: errName });
+  }
+  throw new CliError(4, 'unexpected_status', { status: res.status, error: errName });
+}

package/src/seed-extract.mjs

@@ -0,0 +1,40 @@
+const EXTRACT_BEGIN = (name) => `// rwa:extract:begin ${name}`;
+const EXTRACT_END = (name) => `// rwa:extract:end ${name}`;
+
+function extractBlock(seedText, name) {
+  const begin = EXTRACT_BEGIN(name);
+  const end = EXTRACT_END(name);
+  const startIdx = seedText.indexOf(begin);
+  if (startIdx === -1) throw new Error(`seed-extract: missing begin marker for ${name}`);
+  const endIdx = seedText.indexOf(end, startIdx);
+  if (endIdx === -1) throw new Error(`seed-extract: missing end marker for ${name}`);
+  return seedText.slice(startIdx + begin.length, endIdx);
+}
+
+function evalConstBlock(block, name, deps = {}) {
+  // Block contains: `\nconst NAME = { ... };\n`
+  // Evaluate in an isolated function scope. `deps` lets us inject upstream
+  // consts (e.g. SYSTEM_PROMPTS references SYSTEM_PROMPT_RULES via template
+  // interpolation). Block must otherwise reference only built-ins.
+  const depNames = Object.keys(deps);
+  const depValues = depNames.map(k => deps[k]);
+  const fn = new Function(...depNames, `${block}\nreturn ${name};`);
+  return fn(...depValues);
+}
+
+export function extractFromSeed(seedText) {
+  const SYSTEM_PROMPT_RULES = evalConstBlock(
+    extractBlock(seedText, 'SYSTEM_PROMPT_RULES'),
+    'SYSTEM_PROMPT_RULES'
+  );
+  const SYSTEM_PROMPTS = evalConstBlock(
+    extractBlock(seedText, 'SYSTEM_PROMPTS'),
+    'SYSTEM_PROMPTS',
+    { SYSTEM_PROMPT_RULES }
+  );
+  const TOOL_SCHEMAS = evalConstBlock(
+    extractBlock(seedText, 'TOOL_SCHEMAS'),
+    'TOOL_SCHEMAS'
+  );
+  return { SYSTEM_PROMPTS, SYSTEM_PROMPT_RULES, TOOL_SCHEMAS };
+}