fullstackgtm 0.47.0 → 0.49.0

package/dist/planStore.js

@@ -1,7 +1,9 @@
-import { chmodSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { chmodSync, closeSync, mkdirSync, openSync, readdirSync, unlinkSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { credentialsDir, ensureSecureHomeDir, writeSecureFile } from "./credentials.js";
 import { computeApprovalDigests, loadOrCreateSigningKey } from "./integrity.js";
+import { assertNoSymlinkComponents, readSecureRegularFile, UnsafeManagedPathError } from "./secureFile.js";
 /**
  * Plans as JSON files in a directory (default `$FSGTM_HOME/plans`), one file
  * per plan id. Filesystem-shaped on purpose: greppable, diffable, and any
@@ -9,6 +11,11 @@ import { computeApprovalDigests, loadOrCreateSigningKey } from "./integrity.js";
  */
 export function createFilePlanStore(directory) {
     const dir = directory ?? join(credentialsDir(), "plans");
+    function ensurePlanDirectory() {
+        assertNoSymlinkComponents(dir);
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        assertNoSymlinkComponents(dir);
+    }
     function pathFor(planId) {
         if (!/^[\w.-]+$/.test(planId))
             throw new Error(`Invalid plan id: ${planId}`);
@@ -16,9 +23,12 @@ export function createFilePlanStore(directory) {
     }
     function read(planId) {
         try {
-            return JSON.parse(readFileSync(pathFor(planId), "utf8"));
+            assertNoSymlinkComponents(dir);
+            return JSON.parse(readSecureRegularFile(pathFor(planId)));
         }
-        catch {
+        catch (error) {
+            if (error instanceof UnsafeManagedPathError)
+                throw error;
             return null;
         }
     }
@@ -29,14 +39,18 @@ export function createFilePlanStore(directory) {
         // directory world-readable.
         if (!directory)
             ensureSecureHomeDir();
-        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        ensurePlanDirectory();
         try {
             chmodSync(dir, 0o700);
         }
         catch {
             // Non-POSIX filesystems ignore chmod.
         }
-        const next = { ...stored, updatedAt: new Date().toISOString() };
+        const next = {
+            ...stored,
+            revision: (stored.revision ?? 0) + 1,
+            updatedAt: new Date().toISOString(),
+        };
         writeSecureFile(pathFor(stored.plan.id), `${JSON.stringify(next, null, 2)}\n`);
         return next;
     }
@@ -46,23 +60,56 @@ export function createFilePlanStore(directory) {
             throw new Error(`No stored plan with id ${planId}.`);
         return stored;
     }
+    function withPlanLock(planId, action) {
+        ensurePlanDirectory();
+        const lockPath = `${pathFor(planId)}.lock`;
+        let fd;
+        try {
+            fd = openSync(lockPath, "wx", 0o600);
+        }
+        catch (error) {
+            const code = error instanceof Error && "code" in error ? String(error.code) : "unknown";
+            if (code === "EEXIST") {
+                throw new Error(`Plan ${planId} is being updated by another process; retry after it finishes.`);
+            }
+            throw error;
+        }
+        try {
+            return action();
+        }
+        finally {
+            closeSync(fd);
+            try {
+                unlinkSync(lockPath);
+            }
+            catch { /* a missing lock is already released */ }
+        }
+    }
     return {
         async save(plan) {
-            const now = new Date().toISOString();
-            return write({
-                plan,
-                status: plan.status,
-                approvedOperationIds: [],
-                valueOverrides: {},
-                runs: [],
-                createdAt: now,
-                updatedAt: now,
+            return withPlanLock(plan.id, () => {
+                const existing = read(plan.id);
+                if (existing && ["approved", "applying", "applied"].includes(existing.status)) {
+                    throw new Error(`Plan ${plan.id} is already ${existing.status}; refusing to replace its approval or apply history.`);
+                }
+                const now = new Date().toISOString();
+                return write({
+                    plan,
+                    status: plan.status,
+                    approvedOperationIds: [],
+                    valueOverrides: {},
+                    revision: 0,
+                    runs: [],
+                    createdAt: now,
+                    updatedAt: now,
+                });
             });
         },
         async get(planId) {
             return read(planId);
         },
         async list(status) {
+            assertNoSymlinkComponents(dir);
             let entries = [];
             try {
                 entries = readdirSync(dir);
@@ -78,46 +125,145 @@ export function createFilePlanStore(directory) {
             return status ? plans.filter((stored) => stored.status === status) : plans;
         },
         async approveOperations(planId, operationIds, valueOverrides = {}) {
-            const stored = mustRead(planId);
-            if (stored.status === "applied") {
-                throw new Error(`Plan ${planId} has already been applied.`);
-            }
-            if (stored.status === "rejected") {
-                throw new Error(`Plan ${planId} was rejected; re-run the audit for a fresh plan.`);
-            }
-            const known = new Set(stored.plan.operations.map((operation) => operation.id));
-            for (const operationId of operationIds) {
-                if (!known.has(operationId)) {
-                    throw new Error(`Plan ${planId} has no operation ${operationId}.`);
+            return withPlanLock(planId, () => {
+                const stored = mustRead(planId);
+                if (stored.status === "applied") {
+                    throw new Error(`Plan ${planId} has already been applied.`);
                 }
-            }
-            const approvedOperationIds = Array.from(new Set([...stored.approvedOperationIds, ...operationIds]));
-            const mergedOverrides = { ...stored.valueOverrides, ...valueOverrides };
-            // Bind the approval to the operation content so apply can detect a
-            // post-approval edit. Recompute over ALL approved ops (a later approve
-            // call may add overrides that change an earlier op's resolved value).
-            const approvalDigests = computeApprovalDigests(stored.plan.operations, approvedOperationIds, mergedOverrides, loadOrCreateSigningKey());
-            return write({
-                ...stored,
-                status: "approved",
-                approvedOperationIds,
-                valueOverrides: mergedOverrides,
-                approvalDigests,
+                if (stored.status === "rejected") {
+                    throw new Error(`Plan ${planId} was rejected; re-run the audit for a fresh plan.`);
+                }
+                if (stored.status === "applying" || stored.applyClaim) {
+                    throw new Error(`Plan ${planId} is applying; approvals are frozen until the attempt is resolved.`);
+                }
+                const known = new Set(stored.plan.operations.map((operation) => operation.id));
+                for (const operationId of operationIds) {
+                    if (!known.has(operationId)) {
+                        throw new Error(`Plan ${planId} has no operation ${operationId}.`);
+                    }
+                }
+                const approvedOperationIds = Array.from(new Set([...stored.approvedOperationIds, ...operationIds]));
+                const mergedOverrides = { ...stored.valueOverrides, ...valueOverrides };
+                // Bind the approval to the operation content so apply can detect a
+                // post-approval edit. Recompute over ALL approved ops (a later approve
+                // call may add overrides that change an earlier op's resolved value).
+                const approvalDigests = computeApprovalDigests(stored.plan.operations, approvedOperationIds, mergedOverrides, loadOrCreateSigningKey());
+                return write({
+                    ...stored,
+                    status: "approved",
+                    approvedOperationIds,
+                    valueOverrides: mergedOverrides,
+                    approvalDigests,
+                });
             });
         },
         async reject(planId) {
-            const stored = mustRead(planId);
-            if (stored.status === "applied") {
-                throw new Error(`Plan ${planId} has already been applied.`);
-            }
-            return write({ ...stored, status: "rejected", approvedOperationIds: [] });
+            return withPlanLock(planId, () => {
+                const stored = mustRead(planId);
+                if (stored.status === "applied") {
+                    throw new Error(`Plan ${planId} has already been applied.`);
+                }
+                if (stored.status === "applying" || stored.applyClaim) {
+                    throw new Error(`Plan ${planId} is applying and cannot be rejected until the attempt is resolved.`);
+                }
+                return write({ ...stored, status: "rejected", approvedOperationIds: [], applyClaim: undefined });
+            });
+        },
+        async claimApply(planId, metadata) {
+            return withPlanLock(planId, () => {
+                const stored = mustRead(planId);
+                if (stored.status === "applying" || stored.applyClaim) {
+                    throw new Error(`Plan ${planId} is already applying; inspect its recorded attempts before any retry.`);
+                }
+                if (stored.status !== "approved") {
+                    throw new Error(`Plan ${planId} is ${stored.status}; only an approved plan can be claimed for apply.`);
+                }
+                const claimId = randomUUID();
+                const claimedAt = new Date().toISOString();
+                const claimed = write({
+                    ...stored,
+                    status: "applying",
+                    applyClaim: {
+                        id: claimId,
+                        claimedAt,
+                        revision: stored.revision ?? 0,
+                    },
+                    applyAttempts: [...(stored.applyAttempts ?? []), {
+                            id: claimId,
+                            claimedAt,
+                            provider: metadata?.provider ?? "unknown",
+                            source: metadata?.source ?? "cli",
+                            status: "in_progress",
+                        }],
+                });
+                return { stored: claimed, claimId };
+            });
         },
-        async recordRun(planId, run) {
-            const stored = mustRead(planId);
-            return write({
-                ...stored,
-                status: run.status === "applied" || run.status === "partial" ? "applied" : stored.status,
-                runs: [...stored.runs, run],
+        async recordRun(planId, run, claimId) {
+            return withPlanLock(planId, () => {
+                const stored = mustRead(planId);
+                if (stored.status !== "applying" || stored.applyClaim?.id !== claimId) {
+                    throw new Error(`Refusing to record run for plan ${planId}: apply claim is missing or does not match.`);
+                }
+                return write({
+                    ...stored,
+                    status: run.status === "applied" || run.status === "partial" ? "applied" : "approved",
+                    applyClaim: undefined,
+                    applyAttempts: (stored.applyAttempts ?? []).map((attempt) => attempt.id === claimId
+                        ? { ...attempt, status: "completed", resolvedAt: new Date().toISOString() }
+                        : attempt),
+                    runs: [...stored.runs, run],
+                });
+            });
+        },
+        async abortApplyPreflight(planId, claimId, note) {
+            return withPlanLock(planId, () => {
+                const stored = mustRead(planId);
+                if (stored.status !== "applying" || stored.applyClaim?.id !== claimId) {
+                    throw new Error(`Refusing to abort preflight for plan ${planId}: apply claim is missing or does not match.`);
+                }
+                return write({
+                    ...stored,
+                    status: "approved",
+                    applyClaim: undefined,
+                    applyAttempts: (stored.applyAttempts ?? []).map((attempt) => attempt.id === claimId
+                        ? { ...attempt, status: "preflight_aborted", resolvedAt: new Date().toISOString(), note }
+                        : attempt),
+                });
+            });
+        },
+        async markApplyUncertain(planId, claimId) {
+            return withPlanLock(planId, () => {
+                const stored = mustRead(planId);
+                if (stored.status !== "applying" || stored.applyClaim?.id !== claimId)
+                    return stored;
+                return write({
+                    ...stored,
+                    applyAttempts: (stored.applyAttempts ?? []).map((attempt) => attempt.id === claimId
+                        ? { ...attempt, status: "uncertain", note: "Apply exited without a completed run; some provider writes may have landed." }
+                        : attempt),
+                });
+            });
+        },
+        async recoverApply(planId) {
+            return withPlanLock(planId, () => {
+                const stored = mustRead(planId);
+                if (stored.status !== "applying" || !stored.applyClaim) {
+                    throw new Error(`Plan ${planId} has no unresolved apply attempt.`);
+                }
+                // Recovery is deliberately privilege-decaying: discard the old approval.
+                // An operator must inspect the provider, then explicitly approve a fresh attempt.
+                return write({
+                    ...stored,
+                    status: "needs_approval",
+                    applyClaim: undefined,
+                    approvedOperationIds: [],
+                    valueOverrides: {},
+                    approvalDigests: undefined,
+                    applyAttempts: (stored.applyAttempts ?? []).map((attempt) => attempt.id === stored.applyClaim.id
+                        ? { ...attempt, status: "uncertain", resolvedAt: new Date().toISOString(), note: "Operator acknowledged uncertain provider state; approval cleared before any retry." }
+                        : attempt),
+                });
             });
         },
     };

package/dist/providerError.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A persistence-safe provider failure. Third-party response bodies are
+ * deliberately excluded: they can reflect credentials, filters, or PII and
+ * errors are rendered in terminals, MCP responses, and scheduled-run files.
+ */
+export declare class ProviderHttpError extends Error {
+    readonly code = "PROVIDER_HTTP_ERROR";
+    readonly provider: string;
+    readonly operation: string;
+    readonly status: number;
+    readonly retryable: boolean;
+    constructor(provider: string, operation: string, status: number, retryable?: boolean);
+    toJSON(): {
+        code: string;
+        provider: string;
+        operation: string;
+        status: number;
+        retryable: boolean;
+        message: string;
+    };
+}

package/dist/providerError.js

@@ -0,0 +1,30 @@
+/**
+ * A persistence-safe provider failure. Third-party response bodies are
+ * deliberately excluded: they can reflect credentials, filters, or PII and
+ * errors are rendered in terminals, MCP responses, and scheduled-run files.
+ */
+export class ProviderHttpError extends Error {
+    code = "PROVIDER_HTTP_ERROR";
+    provider;
+    operation;
+    status;
+    retryable;
+    constructor(provider, operation, status, retryable = status === 429 || status >= 500) {
+        super(`${provider} ${operation} failed: HTTP ${status}.`);
+        this.name = "ProviderHttpError";
+        this.provider = provider;
+        this.operation = operation;
+        this.status = status;
+        this.retryable = retryable;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            provider: this.provider,
+            operation: this.operation,
+            status: this.status,
+            retryable: this.retryable,
+            message: this.message,
+        };
+    }
+}

package/dist/publicHttp.d.ts

@@ -0,0 +1,28 @@
+export declare const DEFAULT_PUBLIC_HTTP_MAX_BYTES = 5000000;
+export type PublicAddress = {
+    address: string;
+    family: number;
+};
+export type PublicLookup = (hostname: string) => Promise<PublicAddress[]>;
+export declare function ipIsPrivate(ip: string): boolean;
+/** Resolve once and reject the entire hostname if any answer is non-public. */
+export declare function resolvePublicAddresses(hostname: string, lookup?: PublicLookup): Promise<PublicAddress[]>;
+export declare function assertPublicUrl(rawUrl: string, lookup?: PublicLookup): Promise<URL>;
+export type PublicHttpResult = {
+    status: number;
+    headers: Headers;
+    body: Uint8Array;
+    finalUrl: string;
+};
+type HopResult = Omit<PublicHttpResult, "finalUrl">;
+export type PublicRequestHop = (url: URL, addresses: PublicAddress[], headers: Record<string, string>, timeoutMs: number, maxBytes: number) => Promise<HopResult>;
+/** Public-only GET with DNS pinning, bounded bodies, and per-hop redirect validation. */
+export declare function publicHttpGet(rawUrl: string, options?: {
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+    maxBytes?: number;
+    maxRedirects?: number;
+    lookup?: PublicLookup;
+    requestHop?: PublicRequestHop;
+}): Promise<PublicHttpResult>;
+export {};

package/dist/publicHttp.js

@@ -0,0 +1,143 @@
+import { lookup as dnsLookup } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
+export const DEFAULT_PUBLIC_HTTP_MAX_BYTES = 5_000_000;
+function ipv4IsPrivate(ip) {
+    const parts = ip.split(".").map(Number);
+    if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255))
+        return true;
+    const [a, b, c] = parts;
+    return a === 0 || a === 10 || a === 127 || (a === 100 && b >= 64 && b <= 127) ||
+        (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31) ||
+        (a === 192 && b === 0 && (c === 0 || c === 2)) || (a === 192 && b === 168) ||
+        (a === 198 && (b === 18 || b === 19 || (b === 51 && c === 100))) ||
+        (a === 203 && b === 0 && c === 113) || a >= 224;
+}
+function embeddedIpv4IsPrivate(high, low) {
+    const hi = Number.parseInt(high, 16);
+    const lo = Number.parseInt(low, 16);
+    if (!Number.isInteger(hi) || !Number.isInteger(lo) || hi > 0xffff || lo > 0xffff)
+        return true;
+    return ipv4IsPrivate(`${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`);
+}
+export function ipIsPrivate(ip) {
+    const family = isIP(ip);
+    if (family === 4)
+        return ipv4IsPrivate(ip);
+    if (family !== 6)
+        return true;
+    const lower = ip.toLowerCase();
+    if (lower === "::" || lower === "::1")
+        return true;
+    const embedded = lower.match(/^::(?:ffff:)?([0-9a-f]+):([0-9a-f]+)$/);
+    if (embedded)
+        return embeddedIpv4IsPrivate(embedded[1], embedded[2]);
+    const embeddedDotted = lower.match(/^::(?:ffff:)?(.+\..+)$/);
+    if (embeddedDotted)
+        return ipv4IsPrivate(embeddedDotted[1]);
+    const nat64 = lower.match(/^64:ff9b::([0-9a-f]+):([0-9a-f]+)$/);
+    if (nat64)
+        return embeddedIpv4IsPrivate(nat64[1], nat64[2]);
+    const sixToFour = lower.match(/^2002:([0-9a-f]+):([0-9a-f]+):/);
+    if (sixToFour)
+        return embeddedIpv4IsPrivate(sixToFour[1], sixToFour[2]);
+    return /^(?:fc|fd)/.test(lower) || /^(?:fe8|fe9|fea|feb)/.test(lower) ||
+        lower.startsWith("ff") || lower.startsWith("100:") ||
+        lower.startsWith("2001:db8:") || lower.startsWith("2001:0:") ||
+        lower.startsWith("2001:10:") || lower.startsWith("3fff:") ||
+        lower.startsWith("64:ff9b:1:");
+}
+const systemLookup = async (hostname) => (await dnsLookup(hostname, { all: true, verbatim: true })).map(({ address, family }) => ({ address, family }));
+/** Resolve once and reject the entire hostname if any answer is non-public. */
+export async function resolvePublicAddresses(hostname, lookup = systemLookup) {
+    const literal = hostname.replace(/^\[|\]$/g, "");
+    const family = isIP(literal);
+    const addresses = family ? [{ address: literal, family }] : await lookup(literal);
+    if (addresses.length === 0)
+        throw new Error(`public HTTP: ${literal} did not resolve to an address.`);
+    for (const { address } of addresses) {
+        if (ipIsPrivate(address))
+            throw new Error(`public HTTP refuses ${literal} — it resolves to private/internal address ${address} (SSRF guard).`);
+    }
+    return addresses;
+}
+export async function assertPublicUrl(rawUrl, lookup = systemLookup) {
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        throw new Error(`market capture: "${rawUrl}" is not a valid URL.`);
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error(`market capture refuses ${url.protocol} URLs (only http/https): ${rawUrl}`);
+    }
+    const host = url.hostname.replace(/^\[|\]$/g, "");
+    if (isIP(host) && ipIsPrivate(host)) {
+        throw new Error(`market capture refuses private/loopback address ${host} (SSRF guard).`);
+    }
+    const addresses = await resolvePublicAddresses(host, lookup);
+    // Keep the resolved set available to the request path without changing the public API.
+    Object.defineProperty(url, "__publicAddresses", { value: addresses });
+    return url;
+}
+const requestHop = (url, addresses, headers, timeoutMs, maxBytes) => new Promise((resolve, reject) => {
+    let cursor = 0;
+    const options = {
+        protocol: url.protocol, hostname: url.hostname, port: url.port || undefined,
+        path: `${url.pathname}${url.search}`, method: "GET", headers,
+        lookup: (_hostname, options, callback) => {
+            const requestedFamily = typeof options === "number" ? options : options?.family;
+            const eligible = requestedFamily ? addresses.filter((a) => a.family === requestedFamily) : addresses;
+            const selected = eligible[cursor++ % eligible.length];
+            if (!selected)
+                return callback(new Error("public HTTP: no validated address matches the requested family"), "", 0);
+            callback(null, selected.address, selected.family);
+        },
+    };
+    const req = (url.protocol === "https:" ? httpsRequest : httpRequest)(options, (res) => {
+        if (maxBytes === 0) {
+            resolve({ status: res.statusCode ?? 0, headers: new Headers(res.headers), body: new Uint8Array() });
+            res.destroy();
+            return;
+        }
+        const chunks = [];
+        let total = 0;
+        res.on("data", (chunk) => {
+            total += chunk.length;
+            if (total > maxBytes) {
+                req.destroy(new Error(`public HTTP response exceeds ${maxBytes} bytes`));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        res.on("end", () => resolve({ status: res.statusCode ?? 0, headers: new Headers(res.headers), body: Buffer.concat(chunks) }));
+    });
+    req.setTimeout(timeoutMs, () => req.destroy(new Error(`public HTTP request timed out after ${timeoutMs}ms`)));
+    req.on("error", reject);
+    req.end();
+});
+const SENSITIVE_HEADERS = new Set(["authorization", "cookie", "proxy-authorization"]);
+/** Public-only GET with DNS pinning, bounded bodies, and per-hop redirect validation. */
+export async function publicHttpGet(rawUrl, options = {}) {
+    let current = rawUrl;
+    let headers = { ...(options.headers ?? {}) };
+    const maxRedirects = options.maxRedirects ?? 5;
+    for (let hop = 0; hop <= maxRedirects; hop++) {
+        const url = await assertPublicUrl(current, options.lookup);
+        const addresses = url.__publicAddresses;
+        const result = await (options.requestHop ?? requestHop)(url, addresses, headers, options.timeoutMs ?? 15_000, options.maxBytes ?? DEFAULT_PUBLIC_HTTP_MAX_BYTES);
+        const location = result.headers.get("location");
+        if (result.status >= 300 && result.status < 400 && location) {
+            const next = new URL(location, url);
+            if (next.origin !== url.origin) {
+                headers = Object.fromEntries(Object.entries(headers).filter(([key]) => !SENSITIVE_HEADERS.has(key.toLowerCase())));
+            }
+            current = next.toString();
+            continue;
+        }
+        return { ...result, finalUrl: current };
+    }
+    throw new Error(`public HTTP: too many redirects (>${maxRedirects}) for ${rawUrl}`);
+}

package/dist/relationships.d.ts

@@ -0,0 +1,39 @@
+import type { CanonicalGtmSnapshot } from "./types.ts";
+export type StakeholderRole = "economic_buyer" | "decision_maker" | "technical_buyer" | "champion" | "influencer" | "unknown";
+export type StakeholderSentiment = "positive" | "neutral" | "negative" | "unknown";
+export type StakeholderNode = {
+    contactId: string;
+    name: string;
+    title?: string;
+    email?: string;
+    role: StakeholderRole;
+    sentiment: StakeholderSentiment;
+    lastActivityAt?: string;
+    evidence: string[];
+};
+export type RelationshipMap = {
+    account: {
+        accountId: string;
+        name: string;
+        domain?: string;
+    };
+    stakeholders: StakeholderNode[];
+    openDeals: Array<{
+        dealId: string;
+        name: string;
+        stage?: string;
+        amount?: number;
+        ownerId?: string;
+    }>;
+    gaps: string[];
+    counts: {
+        stakeholders: number;
+        openDeals: number;
+        activities: number;
+    };
+};
+export declare function buildRelationshipMap(snapshot: CanonicalGtmSnapshot, selector: {
+    accountId?: string;
+    domain?: string;
+}): RelationshipMap;
+export declare function relationshipMapToMarkdown(map: RelationshipMap): string;