railcode 0.1.26 → 0.1.28

package/dist/manifest.js

@@ -48,7 +48,7 @@ const SAVED_QUERY_NAME = /^[a-z0-9_]{1,80}$/;
 // Mirrors the server's _PERSONAL_CONNECTOR_RE exactly. The server is
 // authoritative; this exists so `railcode deploy` can reject a bad manifest
 // locally instead of after a round trip.
-const PERSONAL_CONNECTOR = /^[a-z0-9][a-z0-9_]{0,63}(?::(?:\*|[A-Z0-9_]{1,120}))?$/;
+const PERSONAL_CONNECTOR = /^[a-z0-9][a-z0-9_]{0,63}(?::(?:\*|[A-Za-z0-9_]{1,120}))?$/;
 // PyYAML's YAML 1.1 plain-scalar resolver: a bare (unquoted) scalar matching one
 // of these resolves to a non-string (bool/null/int/float/timestamp), and the
 // server rejects a non-string wherever the manifest wants a name. The quirks are
@@ -653,7 +653,7 @@ function validateDoc(doc, lines) {
     doc.agents = [...new Set(doc.agents)].sort();
     for (const entry of doc.personal_connectors) {
         if (!PERSONAL_CONNECTOR.test(entry)) {
-            throw new ManifestParseError(`"${entry}" is not a valid personal_connectors entry — use "gmail", "gmail:*", or "gmail:GMAIL_SEND_EMAIL"`, lineOf(entry));
+            throw new ManifestParseError(`"${entry}" is not a valid personal_connectors entry — use "gmail", "gmail:*", or "gmail:send_email"`, lineOf(entry));
         }
     }
     doc.personal_connectors = [...new Set(doc.personal_connectors)].sort();

package/dist/orgadmin.js

@@ -178,14 +178,26 @@ export function renderEffective(eff, who) {
     return lines.join("\n");
 }
 export function appTable(apps) {
-    return formatTable(["slug", "name", "status", "access", "your_role", "manage"], apps.map((a) => [
-        a.app_slug,
-        a.name,
-        a.status,
-        a.access_mode,
-        a.your_role ?? "-",
-        a.can_manage ? "yes" : "no",
-    ]));
+    // The `archived` column only appears when something in the list actually IS
+    // archived (i.e. `apps list --archived/--all`), so the default listing is
+    // unchanged for the many people who never archive anything.
+    const showArchived = apps.some((a) => a.archived_at);
+    const columns = ["slug", "name", "status", "access", "your_role", "manage"];
+    if (showArchived)
+        columns.push("archived");
+    return formatTable(columns, apps.map((a) => {
+        const row = [
+            a.app_slug,
+            a.name,
+            a.status,
+            a.access_mode,
+            a.your_role ?? "-",
+            a.can_manage ? "yes" : "no",
+        ];
+        if (showArchived)
+            row.push(a.archived_at ? "yes" : "-");
+        return row;
+    }));
 }
 // Resolve an app reference — a slug (preferred) or a UUID — against a fetched app
 // list.

package/dist/update.js

@@ -0,0 +1,112 @@
+// Self-update support for the `railcode` CLI.
+//
+// Every command run (for a human at an interactive terminal) checks — at most
+// once every 6 hours — whether a newer version is published on the npm registry
+// *within the current major* and, if so, installs it globally and tells the
+// user. The throttle timestamp lives in `~/.railcode/update-check.json`.
+//
+// This file holds only the pure, side-effect-free helpers (version math, the
+// throttle predicate, installer detection) plus the registry fetch, so they can
+// be unit-tested in isolation. The orchestration that reads/writes the state
+// file and spawns the installer lives in `index.ts`.
+export const UPDATE_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+// Parse a `MAJOR.MINOR.PATCH[-prerelease][+build]` string (a leading `v` is
+// tolerated). Returns null for anything that isn't a plain release triple.
+export function parseSemver(input) {
+    const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(input.trim());
+    if (!match)
+        return null;
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4] ?? null,
+    };
+}
+// Compare release precedence by (major, minor, patch). Prerelease ordering is
+// intentionally ignored — we exclude prereleases from update candidates.
+export function compareSemver(a, b) {
+    if (a.major !== b.major)
+        return a.major - b.major;
+    if (a.minor !== b.minor)
+        return a.minor - b.minor;
+    return a.patch - b.patch;
+}
+// From all published versions, pick the highest stable release that shares the
+// current major and is strictly newer than it. Prereleases and other majors are
+// skipped, so we never auto-jump across a breaking major boundary. Returns the
+// raw version string to install, or null when already up to date.
+export function pickLatestSameMajor(current, versions) {
+    const cur = parseSemver(current);
+    if (!cur)
+        return null;
+    let best = null;
+    for (const raw of versions) {
+        const sv = parseSemver(raw);
+        if (!sv)
+            continue;
+        if (sv.prerelease)
+            continue; // stable releases only
+        if (sv.major !== cur.major)
+            continue; // stay within the current major
+        if (compareSemver(sv, cur) <= 0)
+            continue; // must be strictly newer
+        if (!best || compareSemver(sv, best.sv) > 0)
+            best = { raw, sv };
+    }
+    return best ? best.raw : null;
+}
+// Decide whether enough time has passed to check again. Missing or unparseable
+// timestamps always check (and get rewritten with a valid one).
+export function shouldCheckForUpdate(lastCheckedIso, nowMs, intervalMs = UPDATE_CHECK_INTERVAL_MS) {
+    if (!lastCheckedIso)
+        return true;
+    const last = Date.parse(lastCheckedIso);
+    if (Number.isNaN(last))
+        return true;
+    return nowMs - last >= intervalMs;
+}
+// Best-effort detection of the global package manager that owns this install, so
+// the self-update uses the same tool the user installed with. We look at the
+// install path first, then the `npm_config_user_agent` a manager sets when it
+// spawns a script. Defaults to npm (the documented install path).
+export function detectGlobalInstaller(installPath, userAgent) {
+    const path = installPath.replace(/\\/g, "/").toLowerCase();
+    const ua = (userAgent ?? "").toLowerCase();
+    if (ua.startsWith("pnpm") || /\/\.?pnpm\//.test(path)) {
+        return { manager: "pnpm", command: "pnpm", args: (spec) => ["add", "-g", spec] };
+    }
+    if (ua.startsWith("yarn") || /\/\.?yarn\//.test(path)) {
+        return { manager: "yarn", command: "yarn", args: (spec) => ["global", "add", spec] };
+    }
+    if (ua.startsWith("bun") || /\/\.bun\//.test(path)) {
+        return { manager: "bun", command: "bun", args: (spec) => ["add", "-g", spec] };
+    }
+    return { manager: "npm", command: "npm", args: (spec) => ["install", "-g", spec] };
+}
+// Fetch every published version of `pkg` from an npm-compatible registry. Uses
+// the abbreviated packument (much smaller than the full doc) and a hard timeout,
+// and returns [] on any failure — the caller treats "couldn't check" as "no
+// update", never an error.
+export async function fetchPackageVersions(registryBase, pkg, timeoutMs = 4000) {
+    const base = registryBase.replace(/\/+$/, "");
+    const url = `${base}/${encodeURIComponent(pkg).replace(/^%40/, "@")}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, {
+            headers: { accept: "application/vnd.npm.install-v1+json" },
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            return [];
+        const body = (await res.json());
+        return body.versions ? Object.keys(body.versions) : [];
+    }
+    catch {
+        return [];
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "railcode",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "Developer CLI for the multi-tenant Railcode platform: log in, scaffold, and deploy static apps.",
   "license": "MIT",
   "type": "module",
@@ -27,5 +27,8 @@
   "devDependencies": {
     "@types/node": "^24.0.0",
     "typescript": "^5.9.0"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
   }
 }