@s-gw/s-gw 0.1.0

package/dist/executor.js

@@ -0,0 +1,297 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { assertActionAllowed } from "./store.js";
+import { sanitizeKnownSecrets } from "./scanner.js";
+import { runOwnedSshSession } from "./ssh.js";
+export async function executeApprovedRequest(store, requestId, options = {}) {
+    const request = await store.claimApprovedRequest(requestId);
+    try {
+        const secretRecord = await store.getSecretRecord(request.handle);
+        assertActionAllowed(secretRecord, request.action);
+        const secretValue = await store.revealSecretForLocalUse(request.handle, request);
+        const extraSecrets = await resolveExtraSecrets(store, request);
+        const summary = request.action.kind === "ssh_session"
+            ? await runOwnedSshSession(request, secretRecord, secretValue, store.home)
+            : await runEnvCommand(request, secretRecord, secretValue, extraSecrets, options);
+        await store.markExecuted(requestId, summary);
+        return summary;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await store.markFailed(requestId, message);
+        throw error;
+    }
+}
+async function runEnvCommand(request, secretRecord, secretValue, extraSecrets, options) {
+    const engine = executionEngine(options.engine);
+    const coreBinary = options.coreBinary || rustCoreBinary();
+    if (engine !== "typescript" && existsSync(coreBinary)) {
+        return runRustEnvCommand(coreBinary, request, secretRecord, secretValue, extraSecrets);
+    }
+    if (engine === "rust") {
+        throw new Error(`Rust execution core is unavailable: ${coreBinary}`);
+    }
+    return runTypeScriptEnvCommand(request, secretRecord, secretValue, extraSecrets);
+}
+async function runRustEnvCommand(coreBinary, request, secretRecord, secretValue, extraSecrets) {
+    const maxOutput = secretRecord.policy.maxOutputBytes || 16_384;
+    const child = spawn(coreBinary, ["execute"], {
+        env: buildCoreEnv(),
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    const responseLimit = Math.max(1_048_576, maxOutput * 4);
+    child.stdout.on("data", (chunk) => {
+        stdout = appendBounded(stdout, chunk.toString("utf8"), responseLimit);
+    });
+    child.stderr.on("data", (chunk) => {
+        stderr = appendBounded(stderr, chunk.toString("utf8"), responseLimit);
+    });
+    const completion = new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("close", (code, signal) => resolve({ code, signal }));
+    });
+    child.stdin.end(JSON.stringify({
+        version: 1,
+        requestId: request.id,
+        handle: request.handle,
+        command: request.action.command,
+        args: request.action.args,
+        injectEnv: request.action.injectEnv,
+        secretValue,
+        env: extraSecrets.map((item) => ({
+            handle: item.handle,
+            injectEnv: item.injectEnv,
+            value: item.value
+        })),
+        workingDir: request.action.workingDir,
+        timeoutMs: request.action.timeoutMs,
+        maxOutputBytes: maxOutput
+    }));
+    const status = await completion;
+    if (status.code !== 0) {
+        throw new Error(stderr.trim() || `Rust execution core exited ${status.code ?? status.signal ?? "unexpectedly"}.`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error("Rust execution core returned an invalid response.");
+    }
+    const summary = parseCoreSummary(parsed, request);
+    const secretValues = [secretValue, ...extraSecrets.map((item) => item.value)];
+    if (secretValues.some((value) => summary.stdout.includes(value) || summary.stderr.includes(value))) {
+        throw new Error("Rust execution core returned unsanitized output.");
+    }
+    const expectedProof = proofFor(request, summary.stdout, summary.stderr);
+    if (summary.proof !== expectedProof) {
+        throw new Error("Rust execution core returned an invalid execution proof.");
+    }
+    return summary;
+}
+function parseCoreSummary(value, request) {
+    if (!value || typeof value !== "object") {
+        throw new Error("Rust execution core returned an invalid summary.");
+    }
+    const summary = value;
+    const validExit = summary.exitCode === null || Number.isInteger(summary.exitCode);
+    const validSignal = summary.signal === null || typeof summary.signal === "string";
+    if (!validExit
+        || !validSignal
+        || typeof summary.stdout !== "string"
+        || typeof summary.stderr !== "string"
+        || typeof summary.proof !== "string"
+        || typeof summary.durationMs !== "number"
+        || !Number.isFinite(summary.durationMs)
+        || summary.durationMs < 0
+        || summary.timeoutMs !== request.action.timeoutMs
+        || typeof summary.timedOut !== "boolean"
+        || typeof summary.sanitized !== "boolean") {
+        throw new Error("Rust execution core returned an invalid summary.");
+    }
+    return summary;
+}
+function executionEngine(override) {
+    const configured = override || process.env.SGW_EXECUTION_ENGINE?.trim().toLowerCase() || "auto";
+    if (configured === "auto" || configured === "rust" || configured === "typescript") {
+        return configured;
+    }
+    throw new Error(`Unsupported SGW_EXECUTION_ENGINE value: ${configured}`);
+}
+function rustCoreBinary() {
+    const extension = process.platform === "win32" ? ".exe" : "";
+    return fileURLToPath(new URL(`../dist/native/s-gw-core${extension}`, import.meta.url));
+}
+function buildCoreEnv() {
+    const env = {};
+    const copyKeys = [
+        "HOME",
+        "LANG",
+        "LC_ALL",
+        "LC_CTYPE",
+        "LC_MESSAGES",
+        "LOGNAME",
+        "NO_COLOR",
+        "PATH",
+        "SHELL",
+        "SYSTEMROOT",
+        "TERM",
+        "TMPDIR",
+        "USER",
+        "USERPROFILE",
+        "WINDIR"
+    ];
+    for (const key of copyKeys) {
+        const value = process.env[key];
+        if (value) {
+            env[key] = value;
+        }
+    }
+    env.PATH ||= process.platform === "win32"
+        ? "C:\\Windows\\System32;C:\\Windows"
+        : "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin";
+    return env;
+}
+async function runTypeScriptEnvCommand(request, secretRecord, secretValue, extraSecrets) {
+    const started = Date.now();
+    const maxOutput = secretRecord.policy.maxOutputBytes || 16_384;
+    const secretPairs = [
+        { handle: request.handle, value: secretValue },
+        ...extraSecrets.map((item) => ({ handle: item.handle, value: item.value }))
+    ];
+    const longestSecretBytes = secretPairs.reduce((max, item) => Math.max(max, Buffer.byteLength(item.value, "utf8")), 0);
+    // Capture slightly more than the display cap so a secret that straddles the
+    // boundary is still present in full when we sanitize. Without this headroom,
+    // truncating raw output first could cut a secret in half and leak the prefix.
+    const captureCap = maxOutput + longestSecretBytes;
+    const env = buildExecutionEnv(request.action.injectEnv, secretValue, extraSecrets);
+    const child = spawn(request.action.command, request.action.args, {
+        cwd: request.action.workingDir,
+        env,
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let killTimer;
+    const timeout = request.action.timeoutMs > 0
+        ? setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            killTimer = setTimeout(() => {
+                child.kill("SIGKILL");
+            }, 1_500);
+        }, request.action.timeoutMs)
+        : undefined;
+    child.stdout.on("data", (chunk) => {
+        stdout = appendBounded(stdout, chunk.toString("utf8"), captureCap);
+    });
+    child.stderr.on("data", (chunk) => {
+        stderr = appendBounded(stderr, chunk.toString("utf8"), captureCap);
+    });
+    const status = await new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("close", (code, signal) => resolve({ code, signal }));
+    });
+    if (timeout) {
+        clearTimeout(timeout);
+    }
+    if (killTimer) {
+        clearTimeout(killTimer);
+    }
+    // Sanitize the full captured output BEFORE applying the display cap. Sanitized
+    // text no longer contains the raw secret, so the final byte-cap can never split
+    // a credential and leak a partial value to the caller.
+    const sanitizedStdout = sanitizeKnownSecrets(stdout, secretPairs);
+    const sanitizedStderr = sanitizeKnownSecrets(stderr, secretPairs);
+    const cleanStdout = capBytes(sanitizedStdout, maxOutput);
+    const cleanStderr = capBytes(sanitizedStderr, maxOutput);
+    const summary = {
+        exitCode: timedOut ? 124 : status.code,
+        signal: status.signal,
+        stdout: cleanStdout,
+        stderr: cleanStderr,
+        proof: proofFor(request, cleanStdout, cleanStderr),
+        durationMs: Date.now() - started,
+        timeoutMs: request.action.timeoutMs,
+        timedOut,
+        sanitized: sanitizedStdout !== stdout || sanitizedStderr !== stderr
+    };
+    return summary;
+}
+async function resolveExtraSecrets(store, request) {
+    const out = [];
+    for (const binding of request.action.env || []) {
+        const secret = await store.getSecretRecord(binding.handle);
+        assertActionAllowed(secret, {
+            ...request.action,
+            injectEnv: binding.injectEnv,
+            env: []
+        });
+        out.push({
+            handle: binding.handle,
+            injectEnv: binding.injectEnv,
+            value: await store.revealSecretForLocalUse(binding.handle, request)
+        });
+    }
+    return out;
+}
+function buildExecutionEnv(injectEnv, secretValue, extraSecrets) {
+    const env = {};
+    const copyKeys = [
+        "HOME",
+        "LANG",
+        "LC_ALL",
+        "LC_CTYPE",
+        "LC_MESSAGES",
+        "LOGNAME",
+        "NO_COLOR",
+        "PATH",
+        "SHELL",
+        "TERM",
+        "TMPDIR",
+        "USER"
+    ];
+    for (const key of copyKeys) {
+        const value = process.env[key];
+        if (value) {
+            env[key] = value;
+        }
+    }
+    env.PATH ||= "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin";
+    env[injectEnv] = secretValue;
+    for (const item of extraSecrets) {
+        env[item.injectEnv] = item.value;
+    }
+    return env;
+}
+function appendBounded(current, extra, maxBytes) {
+    const combined = current + extra;
+    if (Buffer.byteLength(combined, "utf8") <= maxBytes) {
+        return combined;
+    }
+    return capBytes(combined, maxBytes);
+}
+function capBytes(text, maxBytes) {
+    if (Buffer.byteLength(text, "utf8") <= maxBytes) {
+        return text;
+    }
+    return text.slice(0, maxBytes) + "\n<<SGW_OUTPUT_TRUNCATED>>";
+}
+function proofFor(request, stdout, stderr) {
+    const digest = createHash("sha256")
+        .update(request.id)
+        .update(request.handle)
+        .update(stdout)
+        .update(stderr)
+        .digest("base64url")
+        .slice(0, 24);
+    return `s-gw-proof:${request.id}:${digest}`;
+}
+//# sourceMappingURL=executor.js.map

package/dist/gateway.d.ts

@@ -0,0 +1,31 @@
+import { SecretStore } from "./store.js";
+import { buildSshSessionAction } from "./ssh.js";
+import type { CommandAction, CommandEnvBinding, ScanResult, SecretPolicy } from "./types.js";
+import type { AddKeychainSecretInput, AddSecretInput } from "./store.js";
+export type LocalSecretBackend = "local" | "keychain";
+export interface ScanOptions {
+    persist?: boolean;
+    source?: string;
+    defaultName?: string;
+    backend?: LocalSecretBackend;
+}
+export interface OnePasswordScanOptions {
+    vault?: string;
+    source?: string;
+    defaultName?: string;
+    policy?: Partial<SecretPolicy>;
+}
+export declare function scanLocalText(store: SecretStore, text: string, options?: ScanOptions): Promise<ScanResult>;
+export declare function addLocalSecret(store: SecretStore, input: AddSecretInput & Pick<AddKeychainSecretInput, "service">, backend?: LocalSecretBackend): Promise<import("./types.js").SecretRecord>;
+export declare function preferredLocalSecretBackend(): LocalSecretBackend;
+export declare function scanTextToOnePassword(store: SecretStore, text: string, options?: OnePasswordScanOptions): Promise<ScanResult>;
+export declare function scanLocalFile(store: SecretStore, filePath: string, options?: ScanOptions): Promise<ScanResult>;
+export declare function buildEnvCommandAction(input: {
+    command: string;
+    args?: string[];
+    injectEnv: string;
+    env?: CommandEnvBinding[];
+    workingDir?: string;
+    timeoutMs?: number;
+}): CommandAction;
+export { buildSshSessionAction };

package/dist/gateway.js

@@ -0,0 +1,114 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createOnePasswordSecretReference } from "./onepassword.js";
+import { previewHandle, scanText } from "./scanner.js";
+import { buildSshSessionAction } from "./ssh.js";
+export async function scanLocalText(store, text, options = {}) {
+    const persist = options.persist === true;
+    const backend = options.backend || "local";
+    return scanText(text, async (candidate) => {
+        if (!persist) {
+            return previewHandle(candidate);
+        }
+        const record = await addLocalSecret(store, {
+            name: nameForCandidate(candidate, options.defaultName),
+            type: candidate.type,
+            provider: candidate.provider,
+            ruleId: candidate.ruleId,
+            severity: candidate.severity,
+            confidence: candidate.confidence,
+            value: candidate.value,
+            source: options.source,
+            policy: {
+                allowedCommands: [],
+                maxOutputBytes: 16_384
+            }
+        }, backend);
+        return record.handle;
+    });
+}
+export async function addLocalSecret(store, input, backend = "local") {
+    if (backend === "keychain") {
+        return store.addKeychainSecret(input);
+    }
+    return store.addSecret(input);
+}
+export function preferredLocalSecretBackend() {
+    const configured = process.env.SGW_SECRET_BACKEND?.trim().toLowerCase();
+    if (configured === "local" || configured === "keychain") {
+        return configured;
+    }
+    if ((process.platform === "darwin" || process.platform === "win32") && process.env.SGW_DISABLE_KEYCHAIN !== "1") {
+        return "keychain";
+    }
+    return "local";
+}
+export async function scanTextToOnePassword(store, text, options = {}) {
+    const vault = options.vault || "Dev";
+    return scanText(text, async (candidate) => {
+        const title = onePasswordTitleForCandidate(candidate, options.defaultName);
+        const created = await createOnePasswordSecretReference({
+            vault,
+            title,
+            type: candidate.type,
+            value: candidate.value,
+            notes: onePasswordNotes(options.source)
+        });
+        const record = await store.addOnePasswordReference({
+            name: title,
+            type: candidate.type,
+            reference: created.reference,
+            source: `onepassword:${vault}`,
+            policy: options.policy || {
+                allowedCommands: [],
+                maxOutputBytes: 16_384
+            }
+        });
+        return record.handle;
+    });
+}
+export async function scanLocalFile(store, filePath, options = {}) {
+    const resolved = path.resolve(filePath);
+    const text = await readFile(resolved, "utf8");
+    return scanLocalText(store, text, {
+        persist: options.persist ?? true,
+        source: resolved,
+        defaultName: options.defaultName || path.basename(resolved),
+        backend: options.backend
+    });
+}
+function onePasswordTitleForCandidate(candidate, defaultName) {
+    const base = defaultName?.trim() || `s-gw captured ${candidate.label || friendlyType(candidate.type)}`;
+    const stamp = new Date().toISOString().replace(/[-:.]/g, "").slice(0, 15);
+    return `${base} ${stamp}-${candidate.start}`;
+}
+function onePasswordNotes(source) {
+    const suffix = source ? ` Source: ${source}` : "";
+    return `Created by s-gw from a credential capture.${suffix}`;
+}
+export function buildEnvCommandAction(input) {
+    return {
+        kind: "env_command",
+        command: input.command,
+        args: input.args || [],
+        injectEnv: input.injectEnv,
+        env: input.env,
+        workingDir: input.workingDir,
+        timeoutMs: input.timeoutMs ?? 30_000
+    };
+}
+function nameForCandidate(candidate, defaultName) {
+    const prefix = defaultName ? `${defaultName} ` : "";
+    return `${prefix}${candidate.label || friendlyType(candidate.type)} ${candidate.start}`;
+}
+function friendlyType(type) {
+    if (type === "api-token") {
+        return "API token";
+    }
+    if (type === "private-key") {
+        return "private key";
+    }
+    return type;
+}
+export { buildSshSessionAction };
+//# sourceMappingURL=gateway.js.map

package/dist/guard.d.ts

@@ -0,0 +1,61 @@
+import { SecretStore } from "./store.js";
+export interface GuardRunOptions {
+    agent: string;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    extraEnv?: Record<string, string>;
+    scrubEnv?: boolean;
+    persist?: boolean;
+    allowedCommands?: string[];
+}
+export interface GuardEnvFinding {
+    name: string;
+    handle: string;
+    token: string;
+    type: string;
+    provider?: string;
+    ruleId?: string;
+    severity?: string;
+}
+export interface GuardRunPlan {
+    agent: {
+        id: string;
+        displayName: string;
+    };
+    command: string;
+    args: string[];
+    cwd: string;
+    mode: "guarded";
+    scrubbedEnv: GuardEnvFinding[];
+    keptEnvCount: number;
+    scrubbedEnvCount: number;
+    mcp: {
+        serverName: string;
+        command: string;
+    };
+    instructions: string;
+    dryRun: boolean;
+    warnings: string[];
+}
+export interface GuardRunPreparation {
+    plan: GuardRunPlan;
+    env: Record<string, string>;
+}
+export declare function guardStatus(): {
+    mode: string;
+    envScrubbing: boolean;
+    rawSecretPolicy: string;
+    configInstall: string;
+    agents: {
+        id: string;
+        displayName: string;
+        mcpStatus: import("./agents.js").AgentMcpStatus;
+        configPaths: string[];
+        defaultRunCommand: string;
+        directRunSupported: boolean;
+    }[];
+};
+export declare function prepareGuardedRun(store: SecretStore, options: GuardRunOptions): Promise<GuardRunPreparation>;
+export declare function runGuardedAgent(store: SecretStore, options: GuardRunOptions): Promise<number>;