@connormartin/seed-network-agent 0.1.0

package/dist/features/submit-deal-pdf/pipeline.js

@@ -0,0 +1,74 @@
+import { createSeedAgentAuthClient, ensureActiveSeedCapability, SEED_SUBMIT_DEAL_CAPABILITY, } from "../../seed-agent-auth.js";
+import { interpretDealText } from "./interpretation.js";
+import { extractPdfText, validateLocalPdf } from "./local-pdf.js";
+import { MAX_SOURCE_CONTENT_CHARS } from "./types.js";
+import { uploadDealDeck } from "./upload-client.js";
+export { extractPdfText, validateLocalPdf } from "./local-pdf.js";
+export { interpretDealText } from "./interpretation.js";
+export async function submitDealSubmission(submission, ui, options = {}) {
+    const client = createSeedAgentAuthClient(ui);
+    try {
+        const connection = await ensureActiveSeedCapability(client, SEED_SUBMIT_DEAL_CAPABILITY, ui, {
+            reason: "Create Seed Network deal records from the local Seed Network Agent submit-deal wizard.",
+            bindingMessage: "Approve Seed Network Agent deal submission",
+        });
+        const prepared = await preparePdfDealSubmission(submission, connection, ui, options);
+        return await client.executeCapability({
+            agentId: connection.agentId,
+            capability: SEED_SUBMIT_DEAL_CAPABILITY,
+            arguments: prepared,
+        });
+    }
+    finally {
+        client.destroy();
+    }
+}
+export async function preparePdfDealSubmission(submission, connection, ui, options = {}) {
+    const deckPath = answerValue(submission.answers.deck_file_path);
+    if (!deckPath)
+        throw new Error("Local PDF deck file path is required.");
+    ui?.notify?.("Validating local PDF deck…", "info");
+    const validated = await validateLocalPdf(deckPath);
+    ui?.notify?.("Extracting deck text locally…", "info");
+    const extraction = await extractPdfText(validated.buffer);
+    ui?.notify?.("Interpreting extracted deal fields locally…", "info");
+    const interpreted = await interpretDealText(extraction.text, options.interpretDealText);
+    const extractionWarnings = [...validated.warnings, ...extraction.warnings];
+    if (extractionWarnings.length > 0) {
+        ui?.notify?.(`PDF extraction warnings:\n${extractionWarnings.join("\n")}`, "warning");
+    }
+    if (interpreted.warnings && interpreted.warnings.length > 0) {
+        ui?.notify?.(`Deal interpretation warnings:\n${interpreted.warnings.join("\n")}`, "warning");
+    }
+    ui?.notify?.("Uploading PDF deck to Seed Network storage…", "info");
+    const deck = await uploadDealDeck(validated, connection);
+    const sanitizedAnswers = omitAnswer(submission.answers, "deck_file_path");
+    const explicitName = answerValue(submission.answers.name);
+    return {
+        ...submission,
+        answers: sanitizedAnswers,
+        ...(explicitName ? { name: explicitName } : {}),
+        deck,
+        extraction: {
+            ...extraction,
+            warnings: extractionWarnings,
+            text: truncate(extraction.text, MAX_SOURCE_CONTENT_CHARS),
+        },
+        interpreted,
+        intake: {
+            warmIntro: answerValue(submission.answers.warm_intro),
+            alreadyInvestor: answerValue(submission.answers.already_investor),
+        },
+    };
+}
+function omitAnswer(answers, questionId) {
+    const { [questionId]: _omitted, ...rest } = answers;
+    return rest;
+}
+function answerValue(answer) {
+    const value = answer?.value?.trim();
+    return value || undefined;
+}
+function truncate(value, maxLength) {
+    return value.length <= maxLength ? value : value.slice(0, maxLength);
+}

package/dist/features/submit-deal-pdf/questionnaire.v1.json

@@ -0,0 +1,47 @@
+{
+  "version": "submit-deal.v1",
+  "title": "Submit deal",
+  "description": "Collect the Seed Network deal intake fields and local PDF deck before creating a deal.",
+  "questions": [
+    {
+      "id": "deck_file_path",
+      "label": "Pitch deck PDF",
+      "type": "text",
+      "required": true,
+      "prompt": "Enter the local file path to the pitch deck PDF.",
+      "placeholder": "~/Downloads/company-deck.pdf"
+    },
+    {
+      "id": "name",
+      "label": "Company",
+      "type": "text",
+      "required": false,
+      "prompt": "What company or deal is this for? Leave blank to infer from the PDF or filename.",
+      "placeholder": "Company name"
+    },
+    {
+      "id": "warm_intro",
+      "label": "Warm intro",
+      "type": "single_select",
+      "required": true,
+      "prompt": "Can you facilitate a warm intro to the founder?",
+      "options": [
+        { "value": "yes", "label": "Yes" },
+        { "value": "no", "label": "No" },
+        { "value": "not_sure", "label": "Not sure" }
+      ]
+    },
+    {
+      "id": "already_investor",
+      "label": "Investor status",
+      "type": "single_select",
+      "required": true,
+      "prompt": "Are you already an investor in this company?",
+      "options": [
+        { "value": "yes", "label": "Yes" },
+        { "value": "no", "label": "No" },
+        { "value": "prefer_not_to_say", "label": "Prefer not to say" }
+      ]
+    }
+  ]
+}

package/dist/features/submit-deal-pdf/register.js

@@ -0,0 +1,100 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { complete } from "@earendil-works/pi-ai";
+import { runOnboardingWizard } from "../../wizard.js";
+import { submitDealSubmission } from "./pipeline.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const submitDealQuestionsPath = path.join(__dirname, "questionnaire.v1.json");
+const DEAL_INTERPRETATION_SYSTEM_PROMPT = [
+    "You extract conservative structured data from startup pitch deck text.",
+    "Return only strict JSON with keys: companyName, summary, founderNames, website, email, socialLinks, valuationUsd, totalAllocationUsd, terms, confidence, warnings.",
+    "Use numeric USD values only when explicitly stated. Put ambiguous financing language in terms. Confidence must be low, medium, or high.",
+].join(" ");
+export function registerSubmitDealPdf(pi) {
+    pi.registerCommand("submit-deal", {
+        description: "Submit a Seed Network deal with a local PDF deck and intake questions",
+        handler: async (_args, ctx) => {
+            if (ctx.hasUI === false) {
+                throw new Error("/submit-deal requires interactive Pi UI.");
+            }
+            await startSubmitDeal(ctx);
+        },
+    });
+}
+async function startSubmitDeal(ctx) {
+    const questionnaire = await loadQuestionnaire(submitDealQuestionsPath);
+    const result = await runOnboardingWizard(ctx.ui, questionnaire, {
+        startMessage: "Submit deal: starting deal intake wizard.",
+        reviewTitle: "Review deal submission",
+        reviewDescription: "Review these deal intake answers before creating the Seed Network deal.",
+        reviewConfirmPrompt: "Create this deal now?",
+        suppressReviewCancelledMessage: true,
+    });
+    if (result.cancelled || !result.submission) {
+        ctx.ui.notify("Deal submission cancelled.", "warning");
+        return;
+    }
+    try {
+        const response = await submitDealSubmission(result.submission, ctx.ui, {
+            interpretDealText: createPiDealInterpreter(ctx),
+        });
+        const data = response.data ?? response.result ?? response;
+        const deal = isRecord(data) && isRecord(data.deal) ? data.deal : null;
+        ctx.ui.notify(formatSubmitDealConfirmation(deal), "info");
+    }
+    catch (error) {
+        ctx.ui.notify(`Seed Network deal submission failed: ${errorMessage(error)}`, "error");
+    }
+}
+function createPiDealInterpreter(ctx) {
+    if (!ctx.model || !ctx.modelRegistry)
+        return undefined;
+    return async (text) => {
+        const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
+        if (!auth.ok || !auth.apiKey) {
+            throw new Error(auth.ok ? `No model credentials available for ${ctx.model.provider}` : auth.error);
+        }
+        const userMessage = {
+            role: "user",
+            content: [{ type: "text", text: `Extract deal fields from this PDF text:\n\n${text}` }],
+            timestamp: Date.now(),
+        };
+        const response = await complete(ctx.model, { systemPrompt: DEAL_INTERPRETATION_SYSTEM_PROMPT, messages: [userMessage] }, { apiKey: auth.apiKey, headers: auth.headers, signal: ctx.signal });
+        if (response.stopReason === "aborted") {
+            throw new Error("Pi model interpretation was cancelled.");
+        }
+        const content = response.content
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("\n")
+            .trim();
+        return JSON.parse(stripJsonFence(content));
+    };
+}
+function stripJsonFence(value) {
+    const match = value.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+    return match?.[1]?.trim() ?? value;
+}
+async function loadQuestionnaire(filePath = submitDealQuestionsPath) {
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatSubmitDealConfirmation(deal) {
+    const name = typeof deal?.name === "string" ? deal.name : "Deal";
+    const slug = typeof deal?.slug === "string" ? deal.slug : undefined;
+    const deckUrl = typeof deal?.deckUrl === "string" ? deal.deckUrl : undefined;
+    return [
+        `✅ ${name} submitted to Seed Network.`,
+        slug ? `View deal: /deals/${slug}` : undefined,
+        deckUrl ? `Pitch deck saved: ${deckUrl}` : undefined,
+        "The intake answers were saved to the deal notes and application data.",
+    ].filter(Boolean).join("\n");
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/features/submit-deal-pdf/types.js

@@ -0,0 +1,3 @@
+export const MAX_DEAL_DECK_BYTES = 25 * 1024 * 1024;
+export const MAX_SOURCE_CONTENT_CHARS = 100_000;
+export const MIN_EXTRACTED_TEXT_CHARS = 200;

package/dist/features/submit-deal-pdf/upload-client.js

@@ -0,0 +1,69 @@
+import { createSeedAgentAuthClient, DEFAULT_PROVIDER_URL, SEED_SUBMIT_DEAL_CAPABILITY } from "../../seed-agent-auth.js";
+export async function uploadDealDeck(validated, connection) {
+    const client = createSeedAgentAuthClient();
+    try {
+        const { token } = await client.signJwt({
+            agentId: connection.agentId,
+            capabilities: [SEED_SUBMIT_DEAL_CAPABILITY],
+        });
+        const form = new FormData();
+        form.set("file", new Blob([validated.buffer], { type: "application/pdf" }), validated.fileName || "deck.pdf");
+        form.set("sha256", validated.sha256);
+        form.set("size", String(validated.size));
+        const response = await fetch(agentUploadUrl(connection), {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+            body: form,
+        });
+        const data = await response.json().catch(() => null);
+        if (!response.ok) {
+            const message = isRecord(data) && typeof data.error === "string" ? data.error : `HTTP ${response.status}`;
+            throw new Error(`PDF deck upload failed: ${message}`);
+        }
+        if (!isRecord(data) || data.ok !== true || !isRecord(data.deck)) {
+            throw new Error("PDF deck upload returned an invalid response.");
+        }
+        return parseDeckMetadata(data.deck);
+    }
+    finally {
+        client.destroy();
+    }
+}
+function parseDeckMetadata(value) {
+    const url = stringProperty(value, "url");
+    const fileName = stringProperty(value, "fileName");
+    const contentType = stringProperty(value, "contentType");
+    const size = numberProperty(value, "size");
+    const sha256 = stringProperty(value, "sha256");
+    if (contentType !== "application/pdf")
+        throw new Error("Uploaded deck response was not a PDF.");
+    return { url, fileName, contentType, size, sha256 };
+}
+function agentUploadUrl(connection) {
+    const configured = process.env.SEED_NETWORK_AGENT_DECK_UPLOAD_URL;
+    if (configured)
+        return configured;
+    try {
+        return new URL("/api/agent/deal-deck-upload", connection.issuer).toString();
+    }
+    catch {
+        return new URL("/api/agent/deal-deck-upload", DEFAULT_PROVIDER_URL).toString();
+    }
+}
+function stringProperty(record, field) {
+    const value = record[field];
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`Upload response missing ${field}.`);
+    return value;
+}
+function numberProperty(record, field) {
+    const value = record[field];
+    if (typeof value !== "number" || !Number.isFinite(value))
+        throw new Error(`Upload response missing ${field}.`);
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/onboarding-extension.js

@@ -0,0 +1 @@
+export { default } from "./extension/index.js";

package/dist/pi.js

@@ -0,0 +1,60 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { maybeNotifyUpdate } from "./update-check.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const agentRoot = path.resolve(__dirname, "..");
+export async function runPi(userArgs = []) {
+    if (shouldCheckForUpdates(userArgs)) {
+        await maybeNotifyUpdate(agentRoot);
+    }
+    const extensionPath = resolveExtensionPath();
+    const systemPromptPath = path.join(agentRoot, "prompts", "SYSTEM.md");
+    const systemPrompt = await readFile(systemPromptPath, "utf8");
+    const piArgs = [
+        "--no-extensions",
+        "--no-skills",
+        "--no-prompt-templates",
+        "--no-themes",
+        "--no-context-files",
+        "--extension",
+        extensionPath,
+        "--append-system-prompt",
+        systemPrompt,
+        ...userArgs,
+    ];
+    const localPiBin = path.join(agentRoot, "node_modules", ".bin", process.platform === "win32" ? "pi.cmd" : "pi");
+    const command = process.env.SEED_NETWORK_AGENT_PI_BIN ?? (existsSync(localPiBin) ? localPiBin : "pi");
+    const child = spawn(command, piArgs, {
+        cwd: process.cwd(),
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            SEED_NETWORK_AGENT_ROOT: agentRoot,
+        },
+    });
+    await new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                process.kill(process.pid, signal);
+                return;
+            }
+            process.exitCode = code ?? 0;
+            resolve();
+        });
+    });
+}
+function resolveExtensionPath() {
+    const compiledExtensionPath = path.join(__dirname, "extension", "index.js");
+    if (existsSync(compiledExtensionPath))
+        return compiledExtensionPath;
+    return path.join(__dirname, "extension", "index.ts");
+}
+function shouldCheckForUpdates(userArgs) {
+    const skipFlags = new Set(["--help", "-h", "--version", "-v", "--offline"]);
+    return !userArgs.some((arg) => skipFlags.has(arg));
+}

package/dist/seed-agent-auth.js

@@ -0,0 +1,211 @@
+import { spawn } from "node:child_process";
+import os from "node:os";
+import { AgentAuthClient } from "@auth/agent";
+import { SeedAgentAuthStorage } from "./agent-auth-storage.js";
+export const SEED_ONBOARDING_CAPABILITY = "submit_onboarding_answers";
+export const SEED_SUBMIT_DEAL_CAPABILITY = "submit_deal";
+export const DEFAULT_PROVIDER_URL = process.env.SEED_NETWORK_AGENT_AUTH_PROVIDER ?? "http://localhost:3000";
+const DEFAULT_SEED_CAPABILITIES = [SEED_ONBOARDING_CAPABILITY, SEED_SUBMIT_DEAL_CAPABILITY];
+export function createSeedAgentAuthClient(ui) {
+    return new AgentAuthClient({
+        storage: new SeedAgentAuthStorage(),
+        allowDirectDiscovery: true,
+        hostName: `Seed Network Agent on ${os.hostname()}`,
+        approvalTimeoutMs: 5 * 60 * 1000,
+        onApprovalRequired: async (approval) => {
+            const message = formatApprovalMessage(approval);
+            ui?.notify?.(message, "info");
+            if (approval.verification_uri_complete) {
+                await openUrl(approval.verification_uri_complete);
+            }
+        },
+        onApprovalStatusChange: async (status) => {
+            ui?.notify?.(`Seed Network Agent approval status: ${status}`, "info");
+        },
+    });
+}
+export async function connectSeedAgent(providerUrl, ui) {
+    const client = createSeedAgentAuthClient(ui);
+    try {
+        return await client.connectAgent({
+            provider: providerUrl,
+            mode: "delegated",
+            name: "Seed Network Agent",
+            capabilities: DEFAULT_SEED_CAPABILITIES,
+            reason: "Sync onboarding answers and submit deal intake records to the connected Seed Network account.",
+            preferredMethod: "device_authorization",
+            bindingMessage: "Approve Seed Network Agent workspace access",
+        });
+    }
+    finally {
+        client.destroy();
+    }
+}
+export async function listSeedAgentConnections() {
+    return new SeedAgentAuthStorage().listAgentConnections();
+}
+export async function syncOnboardingSubmission(submission, ui) {
+    const client = createSeedAgentAuthClient(ui);
+    try {
+        const connection = await ensureActiveSeedCapability(client, SEED_ONBOARDING_CAPABILITY, ui, {
+            reason: "Sync local Seed Network Agent onboarding answers to the connected Seed Network account.",
+            bindingMessage: "Approve Seed Network Agent onboarding sync",
+        });
+        return await client.executeCapability({
+            agentId: connection.agentId,
+            capability: SEED_ONBOARDING_CAPABILITY,
+            arguments: submission,
+        });
+    }
+    finally {
+        client.destroy();
+    }
+}
+export async function getPreferredConnection() {
+    const connections = await listSeedAgentConnections();
+    return connections.find((connection) => hasActiveCapability(connection, SEED_ONBOARDING_CAPABILITY))
+        ?? connections.find((connection) => hasActiveCapability(connection, SEED_SUBMIT_DEAL_CAPABILITY))
+        ?? connections[0];
+}
+export async function ensureActiveSeedCapability(client, capability, ui, approval) {
+    const storage = new SeedAgentAuthStorage();
+    let connection = await getConnectionWithCapability(capability);
+    if (connection)
+        return connection;
+    connection = await getPreferredConnection();
+    if (!connection) {
+        ui?.notify?.(`No Seed Network Agent Auth connection found. Connecting to ${DEFAULT_PROVIDER_URL}…`, "info");
+        await connectSeedAgent(DEFAULT_PROVIDER_URL, ui);
+        connection = await getConnectionWithCapability(capability);
+        if (connection)
+            return connection;
+    }
+    if (!connection) {
+        throw new Error("No Seed Network Agent Auth connection found. Run /seed connect first.");
+    }
+    // Refresh server-side grants before requesting. This recovers from a prior
+    // run where the user approved in the browser after the local command exited.
+    const status = await client.agentStatus(connection.agentId).catch(async (error) => {
+        if (isAgentAuthErrorCode(error, "agent_not_found", "agent_revoked", "agent_expired")) {
+            ui?.notify?.("Stored Seed Network Agent Auth connection is no longer active. Creating a fresh connection…", "warning");
+            await storage.deleteAgentConnection(connection.agentId);
+            return null;
+        }
+        throw error;
+    });
+    if (!status) {
+        await connectSeedAgent(DEFAULT_PROVIDER_URL, ui);
+        const refreshed = await getConnectionWithCapability(capability);
+        if (refreshed)
+            return refreshed;
+        throw new Error(`Seed Network capability was not granted after reconnecting: ${capability}`);
+    }
+    const existingGrant = status.agent_capability_grants.find((grant) => grant.capability === capability);
+    if (existingGrant?.status === "active") {
+        const refreshed = await storage.getAgentConnection(connection.agentId);
+        if (refreshed)
+            return refreshed;
+    }
+    if (existingGrant?.status === "pending") {
+        ui?.notify?.(`Seed Network capability ${capability} is already pending without a reusable approval link. Reconnecting to create a fresh approval request…`, "warning");
+        await client.disconnectAgent(connection.agentId);
+        await connectSeedAgent(DEFAULT_PROVIDER_URL, ui);
+        const refreshed = await getConnectionWithCapability(capability);
+        if (refreshed)
+            return refreshed;
+        throw new Error(`Seed Network capability was not granted after reconnecting: ${capability}`);
+    }
+    ui?.notify?.(`Requesting Seed Network capability: ${capability}…`, "info");
+    const result = await client.requestCapability({
+        agentId: connection.agentId,
+        capabilities: [capability],
+        reason: approval.reason,
+        preferredMethod: "device_authorization",
+        bindingMessage: approval.bindingMessage,
+    });
+    if (result.denied.includes(capability)) {
+        throw new Error(`Seed Network capability denied: ${capability}`);
+    }
+    if (!result.granted.includes(capability)) {
+        ui?.notify?.(`Waiting for Seed Network approval: ${capability}…`, "info");
+        return waitForActiveCapability(client, connection.agentId, capability);
+    }
+    const refreshed = await new SeedAgentAuthStorage().getAgentConnection(connection.agentId);
+    return refreshed ?? connection;
+}
+async function waitForActiveCapability(client, agentId, capability, timeoutMs = 5 * 60 * 1000) {
+    const deadline = Date.now() + timeoutMs;
+    let lastStatus = "unknown";
+    while (Date.now() < deadline) {
+        const status = await client.agentStatus(agentId);
+        lastStatus = status.status;
+        const grant = status.agent_capability_grants.find((candidate) => candidate.capability === capability);
+        if (grant?.status === "active") {
+            const refreshed = await new SeedAgentAuthStorage().getAgentConnection(agentId);
+            if (refreshed)
+                return refreshed;
+        }
+        if (grant?.status === "denied" || grant?.status === "revoked") {
+            throw new Error(`Seed Network capability ${grant.status}: ${capability}`);
+        }
+        if (status.status === "rejected" || status.status === "revoked" || status.status === "expired") {
+            throw new Error(`Seed Network agent ${status.status} while waiting for capability: ${capability}`);
+        }
+        await sleep(2000);
+    }
+    throw new Error(`Timed out waiting for Seed Network capability approval: ${capability} (${lastStatus})`);
+}
+async function getConnectionWithCapability(capability) {
+    const connections = await listSeedAgentConnections();
+    return connections.find((connection) => hasActiveCapability(connection, capability));
+}
+function hasActiveCapability(connection, capability) {
+    return connection.capabilityGrants.some((grant) => grant.capability === capability && grant.status === "active");
+}
+function isAgentAuthErrorCode(error, ...codes) {
+    return typeof error === "object"
+        && error !== null
+        && "code" in error
+        && typeof error.code === "string"
+        && codes.includes(error.code);
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function disconnectSeedAgents(ui) {
+    const connections = await listSeedAgentConnections();
+    const client = createSeedAgentAuthClient(ui);
+    let disconnected = 0;
+    try {
+        for (const connection of connections) {
+            await client.disconnectAgent(connection.agentId);
+            disconnected += 1;
+        }
+    }
+    finally {
+        client.destroy();
+    }
+    return disconnected;
+}
+function formatApprovalMessage(approval) {
+    const lines = ["Seed Network Agent requires browser approval."];
+    if (approval.user_code)
+        lines.push(`Code: ${approval.user_code}`);
+    if (approval.verification_uri_complete)
+        lines.push(approval.verification_uri_complete);
+    else if (approval.verification_uri)
+        lines.push(approval.verification_uri);
+    return lines.join("\n");
+}
+async function openUrl(url) {
+    const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    await new Promise((resolve) => {
+        const child = spawn(command, args, { stdio: "ignore", detached: true });
+        child.on("error", () => resolve());
+        child.on("spawn", () => {
+            child.unref();
+            resolve();
+        });
+    });
+}

package/dist/store.js

@@ -0,0 +1,92 @@
+import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export class OnboardingStore {
+    onboardingDir;
+    progressPath;
+    submissionsDir;
+    constructor(baseDir = path.join(os.homedir(), ".seed-network-agent")) {
+        this.onboardingDir = path.join(baseDir, "onboarding");
+        this.progressPath = path.join(this.onboardingDir, "progress.json");
+        this.submissionsDir = path.join(this.onboardingDir, "submissions");
+    }
+    async loadProgress() {
+        try {
+            const raw = await readFile(this.progressPath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (!parsed.answers || parsed.completedAt)
+                return undefined;
+            return parsed;
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }
+    async recordAnswer(questionnaireVersion, question, answer) {
+        const existing = await this.loadProgress();
+        const now = new Date().toISOString();
+        const progress = {
+            questionnaireVersion,
+            startedAt: existing?.startedAt ?? now,
+            updatedAt: now,
+            answers: {
+                ...(existing?.answers ?? {}),
+                [question.id]: answer,
+            },
+        };
+        await this.writeProgress(progress);
+    }
+    async saveSubmission(submission) {
+        await mkdir(this.submissionsDir, { recursive: true });
+        const fileName = `${safeTimestamp(submission.submittedAt)}.json`;
+        const submissionPath = path.join(this.submissionsDir, fileName);
+        await writeJsonAtomic(submissionPath, submission);
+        const progress = await this.loadProgress();
+        if (progress) {
+            await this.writeProgress({
+                ...progress,
+                updatedAt: submission.submittedAt,
+                completedAt: submission.submittedAt,
+                answers: submission.answers,
+            });
+        }
+        return submissionPath;
+    }
+    async loadLatestSubmission() {
+        try {
+            const entries = await readdir(this.submissionsDir, { withFileTypes: true });
+            const fileNames = entries
+                .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+                .map((entry) => entry.name)
+                .sort()
+                .reverse();
+            for (const fileName of fileNames) {
+                const raw = await readFile(path.join(this.submissionsDir, fileName), "utf8");
+                return JSON.parse(raw);
+            }
+            return undefined;
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT")
+                return undefined;
+            throw error;
+        }
+    }
+    async writeProgress(progress) {
+        await mkdir(this.onboardingDir, { recursive: true });
+        await writeJsonAtomic(this.progressPath, progress);
+    }
+}
+async function writeJsonAtomic(filePath, value) {
+    const tmpPath = `${filePath}.${process.pid}.tmp`;
+    await writeFile(tmpPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    await rename(tmpPath, filePath);
+}
+function safeTimestamp(value) {
+    return value.replace(/[:.]/g, "-");
+}
+function isNodeError(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}