@wenrwa/marketplace-cli 0.8.8 → 0.8.9

package/dist/bridge/envNames.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_ENV_NAMES = exports.ENV_NAMES_CAPABILITY = void 0;
+exports.readEnvNames = readEnvNames;
+exports.handleEnvNamesFrame = handleEnvNamesFrame;
+/**
+ * tp-02 (docs/prd/team-preview.md story 39) — the NAMES in a workspace's
+ * `.env`, never the values.
+ *
+ * Workspace settings shows a "Keys" list so a person can check what they have
+ * saved on their own machine. Values never leave the machine: the file is
+ * parsed here with the SAME parser terminals load it with (repoEnv.ts), the
+ * values are dropped on the spot, and only the names go into any reply.
+ *
+ * Both lanes share this module so they cannot drift:
+ *   - hosted: the relay's `env-names` frame (relayClient.ts) → `env-names-result`
+ *   - local:  GET /local-env-names/:workspaceId on the loopback bridge (server.ts)
+ *
+ * tp-14 reuses the same reply to warn the owner about browser-visible names
+ * (NEXT_PUBLIC_* etc.) before sharing a preview.
+ *
+ * Never logs. Never throws.
+ */
+const path = __importStar(require("path"));
+const repoEnv_1 = require("./repoEnv");
+exports.ENV_NAMES_CAPABILITY = 'env-names';
+/** More than this is not a hand-kept key file; the list is capped, never a value leak. */
+exports.MAX_ENV_NAMES = 500;
+/**
+ * Names in `<root>/.env`, sorted, deduplicated. `{ok:true, names:[]}` when
+ * there is no `.env` (nothing saved yet). A symlinked `.env` is not followed.
+ */
+function readEnvNames(root, deps = repoEnv_1.realRepoEnvDeps) {
+    if (!root)
+        return { ok: false, reason: 'no-folder' };
+    const p = path.join(root, repoEnv_1.DOTENV_FILENAME);
+    let text;
+    try {
+        const st = deps.lstat(p);
+        if (!st)
+            return { ok: true, names: [] };
+        if (!st.isFile())
+            return { ok: false, reason: 'not-a-file' };
+        if (st.size > repoEnv_1.MAX_DOTENV_BYTES)
+            return { ok: false, reason: 'too-large' };
+        text = deps.readFile(p);
+    }
+    catch {
+        return { ok: false, reason: 'unreadable' };
+    }
+    // The values are parsed here and go out of scope with this function.
+    const names = Object.keys((0, repoEnv_1.parseDotenv)(text)).sort().slice(0, exports.MAX_ENV_NAMES);
+    return { ok: true, names };
+}
+/**
+ * The relay's `env-names` frame → its `env-names-result` reply. `requestId`
+ * is echoed so the backend can match concurrent reads. The reply is built
+ * from the names array alone, so no value can ride along.
+ */
+function handleEnvNamesFrame(frame, resolveRoot, deps = repoEnv_1.realRepoEnvDeps) {
+    const requestId = typeof frame.requestId === 'string' ? frame.requestId : undefined;
+    const workspaceId = typeof frame.workspaceId === 'string' ? frame.workspaceId : undefined;
+    const head = {
+        t: 'env-names-result',
+        ...(requestId !== undefined ? { requestId } : {}),
+        ...(workspaceId !== undefined ? { workspaceId } : {}),
+    };
+    if (!workspaceId)
+        return { ...head, ok: false, reason: 'no-folder' };
+    let root;
+    try {
+        root = resolveRoot(workspaceId);
+    }
+    catch {
+        root = null;
+    }
+    const result = readEnvNames(root, deps);
+    return result.ok
+        ? { ...head, ok: true, names: [...result.names] }
+        : { ...head, ok: false, reason: result.reason };
+}

package/dist/bridge/previewCheckout.d.ts

@@ -0,0 +1,136 @@
+export type PreviewMode = 'built' | 'dev';
+export type PreviewStatus = 'stopped'
+/** An update is fetching / installing / building right now. */
+ | 'building' | 'running'
+/** The newest sha failed to install or build. The last good one (if any) still serves. */
+ | 'build_failed'
+/** The newest sha built but never answered on the port. The last good one (if any) still serves. */
+ | 'start_failed'
+/** Nothing could be attempted (see `reason`). */
+ | 'failed';
+export type PreviewFailReason = 'busy_other_workspace' | 'no_repo_url' | 'git_failed' | 'no_package_json' | 'no_start_script' | 'port_in_use'
+/** The app listened beyond 127.0.0.1 and could not be forced to loopback. */
+ | 'unsupported_bind';
+export interface PreviewResult {
+    workspaceId: string;
+    status: PreviewStatus;
+    mode: PreviewMode;
+    /** The sha this request tried to bring up (absent when it never got that far). */
+    sha?: string;
+    /** The sha serving on the preview port right now. */
+    runningSha?: string;
+    /** The newest sha that built successfully. */
+    builtSha?: string;
+    reason?: PreviewFailReason;
+    /** One short, masked sentence for the owner. Never a log dump. */
+    message?: string;
+}
+export interface PreviewGitCredential {
+    token: string;
+    repoFullName?: string;
+}
+export interface PreviewRequest {
+    workspaceId: string;
+    repoUrl?: string;
+    gitCredential?: PreviewGitCredential;
+    mode?: PreviewMode;
+}
+export interface PreviewRunnerOpts {
+    /** Root holding every workspace's preview slots, e.g. /data/previews. */
+    previewsBaseDir: string;
+    /** The owner's working copy for a workspace — read for its `.env` ONLY. */
+    workingCopyDir: (workspaceId: string) => string;
+    /** The one fixed preview port (tp-06's forwarder targets it). */
+    port: number;
+    /** The bridge's env; only PASSTHROUGH_ENV names are taken from it. Default process.env. */
+    baseEnv?: Record<string, string | undefined>;
+    /** How long a started server gets to answer on the port. */
+    readyTimeoutMs?: {
+        built: number;
+        dev: number;
+    };
+    probeIntervalMs?: number;
+    /** Bound on each install / build step. */
+    stepTimeoutMs?: number;
+    /** SIGTERM → SIGKILL grace when stopping a process group. */
+    killGraceMs?: number;
+    /** This machine's non-loopback addresses (the bind check). Default: os.networkInterfaces(). */
+    externalAddresses?: () => string[];
+}
+/** The only names a preview process takes from the bridge's own env. */
+/** The only address a preview app may listen on. */
+export declare const PREVIEW_BIND_HOST = "127.0.0.1";
+export declare const PREVIEW_PASSTHROUGH_ENV: readonly ["PATH", "HOME", "USER", "LANG", "LC_ALL", "TZ", "TMPDIR", "SHELL"];
+/**
+ * The preview env: allowlisted process names < the owner's repo `.env`
+ * (reserved names already removed by loadRepoEnv) < the fixed PORT.
+ * Pure, so the "bridge secrets never reach the preview" rule is testable.
+ */
+export declare function buildPreviewEnv(baseEnv: Record<string, string | undefined>, repoEnv: Record<string, string>, port: number): Record<string, string>;
+/**
+ * Extra args that pin a known framework's server to loopback, appended after
+ * `--` to `npm run <script>`. Only for scripts whose command IS that
+ * framework's server — appending flags to an arbitrary script could break it.
+ * Anything else relies on HOST/HOSTNAME and the runtime bind check.
+ */
+export declare function loopbackArgs(scriptCommand: string): string[];
+/** Non-loopback addresses of this machine (IPv4 + IPv6, link-local scoped). */
+export declare function machineExternalAddresses(): string[];
+/** True when ANY non-loopback address answers on the port, i.e. the app is exposed. */
+export declare function listensBeyondLoopback(port: number, addresses: string[], timeoutMs?: number): Promise<boolean>;
+/** `ref: refs/heads/main\tHEAD` → `main`; null when the remote names no HEAD. */
+export declare function parseSymrefHead(lsRemoteOutput: string): string | null;
+/** Which install command a checkout wants, by lockfile. */
+export declare function installCommand(files: (name: string) => boolean): [string, string[]];
+export declare class PreviewRunner {
+    private readonly opts;
+    private readonly states;
+    /** One port, so one operation at a time across the whole box. */
+    private chain;
+    private orphanSwept;
+    constructor(opts: PreviewRunnerOpts);
+    /** Bring the preview up. Already serving this workspace in this mode → answered as-is. */
+    start(req: PreviewRequest): Promise<PreviewResult>;
+    /** Fetch the default branch again and, when it moved, rebuild and swap. */
+    update(req: PreviewRequest): Promise<PreviewResult>;
+    stop(req: {
+        workspaceId: string;
+    }): Promise<PreviewResult>;
+    /** The masked tail of this workspace's preview log. Owner-scoped by the caller. */
+    logs(req: {
+        workspaceId: string;
+    }): {
+        log: string;
+        truncated: boolean;
+    };
+    status(workspaceId: string): PreviewResult;
+    /** Stop every preview this runner started (bridge shutdown). Exact PIDs only. */
+    shutdown(): Promise<void>;
+    private serialize;
+    private snapshot;
+    private wsDir;
+    private logPath;
+    private pidfilePath;
+    private clearPidfile;
+    /**
+     * A bridge restart loses `states` but not the detached server it started,
+     * which would keep the port. Stop it by the exact PID this module recorded —
+     * only if that PID still leads a process group we would have created.
+     */
+    private sweepOrphans;
+    private otherServingWorkspace;
+    private deploy;
+    /** Bring the previous slot back after a failed swap, if there was one. */
+    private restoreSlot;
+    /** The request's own verdict, plus what is actually serving now. */
+    private withServing;
+    private fail;
+    private syncSlot;
+    private runStep;
+    private spawnServer;
+    private waitReady;
+    /** Stop the process GROUP this module spawned — by its exact leader PID. */
+    private killChild;
+}
+/** Any HTTP answer on 127.0.0.1:port counts as "up". */
+export declare function probeOnce(port: number, timeoutMs?: number): Promise<boolean>;