@mugwork/mug 0.1.0

package/dist/src/commands/workspace.js

@@ -0,0 +1,590 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { getAccountToken, ensureDevEmail } from "./login.js";
+import { init } from "./init.js";
+import { repairScaffolding, ensureSettings } from "./sync.js";
+const API_URL = "https://api.mug.work";
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function getWorkspaceId() {
+    const cwd = process.cwd();
+    const mugJsonPath = join(cwd, "mug.json");
+    if (!existsSync(mugJsonPath)) {
+        console.error("No mug.json found. Run `mug create workspace <name>` or `mug init` first.");
+        process.exit(1);
+    }
+    const config = JSON.parse(readFileSync(mugJsonPath, "utf-8"));
+    if (!config.id) {
+        console.error("Workspace not registered on platform. Run `mug create workspace <name>` to register.");
+        process.exit(1);
+    }
+    return config.id;
+}
+function authHeaders(token) {
+    return { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
+}
+function slugify(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 63);
+}
+function validateSubdomain(subdomain) {
+    if (subdomain.length < 3)
+        return "Subdomain must be at least 3 characters.";
+    if (subdomain.length > 63)
+        return "Subdomain must be 63 characters or fewer.";
+    if (!/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/.test(subdomain))
+        return "Subdomain must be lowercase alphanumeric with hyphens, starting and ending with a letter or number.";
+    return null;
+}
+function openUrl(url) {
+    const { execSync } = require("node:child_process");
+    try {
+        execSync(`open "${url}"`, { stdio: "ignore" });
+    }
+    catch {
+        try {
+            execSync(`xdg-open "${url}"`, { stdio: "ignore" });
+        }
+        catch {
+            // fallback: URL is already printed
+        }
+    }
+}
+export async function createWorkspace(name, opts) {
+    const token = getAccountToken();
+    const validTiers = ["free", "starter", "pro", "business"];
+    const tier = opts.tier ?? "free";
+    if (!validTiers.includes(tier)) {
+        console.error(`Invalid tier: ${tier}. Must be one of: ${validTiers.join(", ")}`);
+        process.exit(1);
+    }
+    const subdomain = opts.subdomain ?? slugify(name);
+    const subdomainError = validateSubdomain(subdomain);
+    if (subdomainError) {
+        console.error(subdomainError);
+        process.exit(1);
+    }
+    console.log(`Checking subdomain "${subdomain}"...`);
+    const checkRes = await fetch(`${API_URL}/workspaces/check-subdomain/${subdomain}`, {
+        headers: authHeaders(token),
+    });
+    if (checkRes.ok) {
+        const check = (await checkRes.json());
+        if (!check.available) {
+            console.error(`Subdomain "${subdomain}" is not available${check.reason ? `: ${check.reason}` : ""}.`);
+            process.exit(1);
+        }
+    }
+    console.log(`Creating workspace "${name}" (${subdomain}.mug.work, ${tier})...`);
+    const res = await fetch(`${API_URL}/workspaces`, {
+        method: "POST",
+        headers: authHeaders(token),
+        body: JSON.stringify({ name, subdomain, tier }),
+    });
+    const data = (await res.json());
+    if (!res.ok || data.error) {
+        console.error(`Failed: ${data.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    console.log(`\nRegistered: ${data.name} (${data.id})`);
+    console.log(`Plan: ${data.planTier}`);
+    console.log(`URL: https://${data.subdomain ?? data.name}.mug.work`);
+    if (data.checkoutUrl) {
+        console.log(`\nOpening Stripe Checkout to activate ${tier} plan...`);
+        console.log(`  ${data.checkoutUrl}`);
+        openUrl(data.checkoutUrl);
+    }
+    console.log("");
+    const cwd = process.cwd();
+    const mugJsonPath = join(cwd, "mug.json");
+    if (existsSync(mugJsonPath)) {
+        repairScaffolding(cwd);
+        ensureSettings(mugJsonPath);
+        const config = JSON.parse(readFileSync(mugJsonPath, "utf-8"));
+        config.id = data.id;
+        if (!config.name)
+            config.name = data.name;
+        config.subdomain = data.subdomain ?? subdomain;
+        writeFileSync(mugJsonPath, JSON.stringify(config, null, 2) + "\n");
+        console.log(`Updated mug.json with workspace ID.`);
+    }
+    else {
+        await init(name);
+        const config = JSON.parse(readFileSync(mugJsonPath, "utf-8"));
+        config.id = data.id;
+        config.subdomain = data.subdomain ?? subdomain;
+        writeFileSync(mugJsonPath, JSON.stringify(config, null, 2) + "\n");
+        console.log(`Scaffolded workspace and registered on platform.`);
+    }
+    ensureDevEmail(mugJsonPath);
+}
+export async function workspaceStatus() {
+    const token = getAccountToken();
+    const workspaceId = getWorkspaceId();
+    const res = await fetch(`${API_URL}/workspaces/${workspaceId}`, {
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        if (res.status === 401) {
+            console.error("Unauthorized. Check your account permissions for this workspace.");
+            process.exit(1);
+        }
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    const ws = (await res.json());
+    console.log(`Workspace: ${ws.name} (${ws.id})`);
+    console.log(`URL: https://${ws.name}.mug.work`);
+    if (ws.domain)
+        console.log(`Domain: ${ws.domain}`);
+    console.log(`Plan: ${ws.plan_tier}`);
+    console.log(`Role: ${ws.role}`);
+    console.log(`Version: ${ws.version}`);
+    if (ws.last_deployed_at) {
+        console.log(`Last deployed: ${ws.last_deployed_at}`);
+    }
+    else {
+        console.log(`Last deployed: never`);
+    }
+    console.log(`\nUse "mug workspace plan" to change plan tier.`);
+}
+export async function workspacePlan() {
+    const token = getAccountToken();
+    const workspaceId = getWorkspaceId();
+    const res = await fetch(`${API_URL}/workspaces/${workspaceId}`, {
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        console.error("Failed to fetch workspace info.");
+        process.exit(1);
+    }
+    const ws = (await res.json());
+    const tiers = ["free", "starter", "pro", "business"];
+    const prices = { free: "$0/mo", starter: "$99/mo", pro: "$299/mo", business: "$599/mo" };
+    const descriptions = {
+        free: "20K ops, 10K records, 100 MB storage",
+        starter: "1M ops, 250K records, 5 GB storage",
+        pro: "10M ops, 2.5M records, 50 GB storage, white-label",
+        business: "50M ops, 25M records, 500 GB storage, custom domain",
+    };
+    console.log(`Workspace: ${ws.name}`);
+    console.log(`Current plan: ${ws.plan_tier}\n`);
+    console.log("Available plans:");
+    for (const t of tiers) {
+        const marker = t === ws.plan_tier ? " ← current" : "";
+        console.log(`  ${tiers.indexOf(t) + 1}. ${t} (${prices[t]})${marker}`);
+        console.log(`     ${descriptions[t]}`);
+    }
+    const available = tiers.filter((t) => t !== ws.plan_tier);
+    const choice = await prompt(`\nSelect plan (1-${tiers.length}), or enter to cancel: `);
+    if (!choice) {
+        console.log("Cancelled.");
+        return;
+    }
+    const idx = parseInt(choice) - 1;
+    if (isNaN(idx) || idx < 0 || idx >= tiers.length) {
+        console.error("Invalid selection.");
+        process.exit(1);
+    }
+    const newTier = tiers[idx];
+    if (newTier === ws.plan_tier) {
+        console.log("Already on that plan.");
+        return;
+    }
+    const direction = tiers.indexOf(newTier) > tiers.indexOf(ws.plan_tier) ? "Upgrade" : "Downgrade";
+    const confirm = await prompt(`${direction} to ${newTier} (${prices[newTier]})? (y/n): `);
+    if (confirm.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        return;
+    }
+    const changeRes = await fetch(`${API_URL}/billing/change-plan`, {
+        method: "POST",
+        headers: authHeaders(token),
+        body: JSON.stringify({ workspaceId, tier: newTier }),
+    });
+    if (!changeRes.ok) {
+        const err = (await changeRes.json());
+        console.error(`Failed: ${err.error ?? changeRes.statusText}`);
+        process.exit(1);
+    }
+    const data = (await changeRes.json());
+    if (data.status === "checkout" && data.url) {
+        console.log(`\nOpening Stripe Checkout...`);
+        console.log(`  ${data.url}`);
+        openUrl(data.url);
+    }
+    else if (data.status === "changed") {
+        console.log(`\nPlan changed to ${data.tier}.`);
+    }
+    else if (data.status === "downgraded") {
+        console.log(`\nDowngraded to ${data.tier}. Changes take effect at end of billing period.`);
+    }
+}
+export async function workspaceInvite(email) {
+    const token = getAccountToken();
+    const workspaceId = getWorkspaceId();
+    const res = await fetch(`${API_URL}/workspaces/${workspaceId}/invite`, {
+        method: "POST",
+        headers: authHeaders(token),
+        body: JSON.stringify({ email, role: "admin" }),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    const data = (await res.json());
+    console.log(`Invite sent to ${data.email} (${data.role}). They'll receive an email to accept.`);
+}
+export async function workspaceTransfer(email) {
+    const token = getAccountToken();
+    const workspaceId = getWorkspaceId();
+    const confirm = await prompt(`Transfer ownership to ${email}? They'll receive an invite to accept. (y/n): `);
+    if (confirm.toLowerCase() !== "y") {
+        console.log("Cancelled.");
+        return;
+    }
+    const res = await fetch(`${API_URL}/workspaces/${workspaceId}/invite`, {
+        method: "POST",
+        headers: authHeaders(token),
+        body: JSON.stringify({ email, role: "owner" }),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    const data = (await res.json());
+    console.log(`Ownership transfer invite sent to ${data.email}. Ownership transfers when they accept.`);
+}
+export async function workspaceRemove(email) {
+    const token = getAccountToken();
+    const workspaceId = getWorkspaceId();
+    const res = await fetch(`${API_URL}/workspaces/${workspaceId}/remove`, {
+        method: "POST",
+        headers: authHeaders(token),
+        body: JSON.stringify({ email }),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    console.log(`Removed ${email} from workspace.`);
+}
+export async function workspaceArchive() {
+    const token = getAccountToken();
+    const workspaceId = getWorkspaceId();
+    const res = await fetch(`${API_URL}/workspaces/${workspaceId}`, {
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        console.error("Failed to fetch workspace info.");
+        process.exit(1);
+    }
+    const ws = (await res.json());
+    const confirm = await prompt(`Type "${ws.name}" to confirm archive: `);
+    if (confirm !== ws.name) {
+        console.log("Cancelled.");
+        return;
+    }
+    const archiveRes = await fetch(`${API_URL}/workspaces/${workspaceId}/archive`, {
+        method: "POST",
+        headers: authHeaders(token),
+    });
+    if (!archiveRes.ok) {
+        const err = (await archiveRes.json());
+        console.error(`Failed: ${err.error ?? archiveRes.statusText}`);
+        process.exit(1);
+    }
+    const data = (await archiveRes.json());
+    console.log(`\nWorkspace archived.`);
+    console.log(`Archived at: ${data.archivedAt}`);
+    console.log(`Data retained for ${data.retentionDays} days. Restore anytime from your account dashboard or CLI.`);
+}
+export async function workspaceRestore() {
+    const token = getAccountToken();
+    const workspaceId = getWorkspaceId();
+    const res = await fetch(`${API_URL}/workspaces/${workspaceId}/restore`, {
+        method: "POST",
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    const data = (await res.json());
+    console.log("Workspace restored.");
+    if (data.checkoutUrl) {
+        console.log(`\nOpening Stripe Checkout to reactivate paid plan...`);
+        console.log(`  ${data.checkoutUrl}`);
+        openUrl(data.checkoutUrl);
+    }
+}
+export async function workspaceDelete() {
+    const token = getAccountToken();
+    const workspaceId = getWorkspaceId();
+    const wsRes = await fetch(`${API_URL}/workspaces/${workspaceId}`, {
+        headers: authHeaders(token),
+    });
+    if (!wsRes.ok) {
+        console.error("Failed to fetch workspace info.");
+        process.exit(1);
+    }
+    const ws = (await wsRes.json());
+    if (ws.status !== "archived") {
+        console.error("Only archived workspaces can be permanently deleted. Run `mug workspace archive` first.");
+        process.exit(1);
+    }
+    console.log("WARNING: This permanently deletes all workspace data. This cannot be undone.");
+    const confirm = await prompt(`Type "${ws.name}" to confirm permanent deletion: `);
+    if (confirm !== ws.name) {
+        console.log("Cancelled.");
+        return;
+    }
+    const res = await fetch(`${API_URL}/workspaces/${workspaceId}/delete`, {
+        method: "POST",
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    console.log("Workspace permanently deleted.");
+}
+function formatBytes(bytes) {
+    if (bytes < 1000)
+        return `${bytes} B`;
+    if (bytes < 1_000_000)
+        return `${(bytes / 1000).toFixed(1)} KB`;
+    return `${(bytes / 1_000_000).toFixed(1)} MB`;
+}
+export async function workspaceExport(opts) {
+    const token = getAccountToken();
+    const workspaceId = getWorkspaceId();
+    console.log("Fetching export manifest...");
+    const manifestRes = await fetch(`${API_URL}/workspaces/${workspaceId}/export-manifest`, {
+        headers: authHeaders(token),
+    });
+    if (!manifestRes.ok) {
+        const err = (await manifestRes.json());
+        console.error(`Failed: ${err.error ?? manifestRes.statusText}`);
+        process.exit(1);
+    }
+    const manifest = (await manifestRes.json());
+    const allCategories = Object.keys(manifest.categories);
+    if (!opts.all && !opts.categories) {
+        console.log(`\nWorkspace: ${manifest.workspace}\n`);
+        console.log("Categories:");
+        for (const [key, cat] of Object.entries(manifest.categories)) {
+            console.log(`  ${key.padEnd(12)} ${String(cat.files).padStart(4)} files  ${formatBytes(cat.bytes).padStart(10)}  ${cat.label}`);
+        }
+        console.log(`\nUse --all to download everything, or --categories config,code,... to select.`);
+        return;
+    }
+    const selectedCategories = opts.all ? allCategories : opts.categories.split(",");
+    console.log(`Requesting export for ${opts.all ? "all categories" : selectedCategories.join(", ")}...`);
+    const res = await fetch(`${API_URL}/workspaces/${workspaceId}/export`, {
+        method: "POST",
+        headers: { ...authHeaders(token), "Content-Type": "application/json" },
+        body: JSON.stringify({ categories: selectedCategories }),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    console.log(`Export is being prepared. Check your inbox for a download link.`);
+}
+export async function accountInvites() {
+    const token = getAccountToken();
+    const res = await fetch(`${API_URL}/auth/me`, {
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        console.error("Failed to fetch account info.");
+        process.exit(1);
+    }
+    const data = (await res.json());
+    const incoming = data.pendingInvites ?? [];
+    const sent = (data.sentInvites ?? []).filter((i) => i.status === "pending");
+    if (incoming.length === 0 && sent.length === 0) {
+        console.log("No pending invites.");
+        return;
+    }
+    if (incoming.length > 0) {
+        console.log("Incoming invites:");
+        for (const inv of incoming) {
+            console.log(`  #${inv.id} — ${inv.workspace_name} (${inv.role}), from ${inv.invited_by_email}`);
+        }
+        console.log(`\n  Accept: mug account accept <id>`);
+        console.log(`  Decline: mug account decline <id>`);
+    }
+    if (sent.length > 0) {
+        if (incoming.length > 0)
+            console.log("");
+        console.log("Sent invites (pending):");
+        for (const inv of sent) {
+            console.log(`  #${inv.id} — ${inv.email} → ${inv.workspace_name} (${inv.role})`);
+        }
+        console.log(`\n  Cancel: mug workspace cancel-invite <id>`);
+    }
+}
+export async function accountAccept(inviteId) {
+    const token = getAccountToken();
+    const res = await fetch(`${API_URL}/invites/${inviteId}/accept`, {
+        method: "POST",
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    const data = (await res.json());
+    console.log(`Invite accepted. You are now ${data.role}.`);
+}
+export async function accountDecline(inviteId) {
+    const token = getAccountToken();
+    const res = await fetch(`${API_URL}/invites/${inviteId}/decline`, {
+        method: "POST",
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    console.log("Invite declined.");
+}
+export async function workspaceCancelInvite(inviteId) {
+    const token = getAccountToken();
+    const res = await fetch(`${API_URL}/invites/${inviteId}`, {
+        method: "DELETE",
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    console.log("Invite cancelled.");
+}
+export async function accountChangeEmail(newEmail) {
+    const token = getAccountToken();
+    const headers = authHeaders(token);
+    const meRes = await fetch(`${API_URL}/auth/me`, { headers });
+    if (!meRes.ok) {
+        console.error("Failed to fetch account info.");
+        process.exit(1);
+    }
+    const me = (await meRes.json());
+    const oldEmail = me.email;
+    console.log(`Current email: ${oldEmail}`);
+    console.log(`New email: ${newEmail}\n`);
+    console.log(`Sending verification code to ${oldEmail}...`);
+    const sendOld = await fetch(`${API_URL}/auth/send-code`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ email: oldEmail }),
+    });
+    if (!sendOld.ok) {
+        console.error("Failed to send verification code to current email.");
+        process.exit(1);
+    }
+    const oldCode = await prompt(`Enter the code sent to ${oldEmail}: `);
+    if (!oldCode) {
+        console.log("Cancelled.");
+        return;
+    }
+    console.log(`Sending verification code to ${newEmail}...`);
+    const sendNew = await fetch(`${API_URL}/auth/send-code`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ email: newEmail }),
+    });
+    if (!sendNew.ok) {
+        console.error("Failed to send verification code to new email.");
+        process.exit(1);
+    }
+    const newCode = await prompt(`Enter the code sent to ${newEmail}: `);
+    if (!newCode) {
+        console.log("Cancelled.");
+        return;
+    }
+    const res = await fetch(`${API_URL}/auth/email`, {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({ email: newEmail, oldCode, newCode }),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    const data = (await res.json());
+    console.log(`\nEmail updated to ${data.email}.`);
+}
+export async function workspaceMembers() {
+    const token = getAccountToken();
+    const workspaceId = getWorkspaceId();
+    const res = await fetch(`${API_URL}/workspaces/${workspaceId}/members`, {
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    const data = (await res.json());
+    console.log("Members:");
+    for (const m of data.members) {
+        console.log(`  ${m.email} — ${m.role} (since ${m.created_at.split("T")[0]})`);
+    }
+    const meRes = await fetch(`${API_URL}/auth/me`, {
+        headers: authHeaders(token),
+    });
+    if (meRes.ok) {
+        const me = (await meRes.json());
+        const pending = me.sentInvites?.filter((i) => i.status === "pending" && i.workspace_id === workspaceId) ?? [];
+        if (pending.length > 0) {
+            console.log("\nPending invites:");
+            for (const inv of pending) {
+                console.log(`  ${inv.email} — ${inv.role} (invite #${inv.id})`);
+            }
+        }
+    }
+}
+export async function workspaceCheckSubdomain(subdomain) {
+    const token = getAccountToken();
+    const error = validateSubdomain(subdomain);
+    if (error) {
+        console.error(error);
+        process.exit(1);
+    }
+    const res = await fetch(`${API_URL}/workspaces/check-subdomain/${subdomain}`, {
+        headers: authHeaders(token),
+    });
+    if (!res.ok) {
+        const err = (await res.json());
+        console.error(`Failed: ${err.error ?? res.statusText}`);
+        process.exit(1);
+    }
+    const data = (await res.json());
+    if (data.available) {
+        console.log(`"${subdomain}" is available — ${subdomain}.mug.work`);
+    }
+    else {
+        console.log(`"${subdomain}" is not available${data.reason ? `: ${data.reason}` : ""}.`);
+    }
+}

package/dist/src/connector-migration.d.ts

@@ -0,0 +1,20 @@
+import type { SourcesConfig, SourceAuth } from "../worker/src/source-types.js";
+interface OldConnection {
+    auth?: SourceAuth;
+    baseUrl?: string;
+}
+interface OldConnector {
+    connection?: string;
+    database?: string;
+    schedule?: string;
+    syncSchedule?: string;
+}
+interface MugConfig {
+    sources?: SourcesConfig;
+    connections?: Record<string, OldConnection>;
+    connectors?: Record<string, OldConnector>;
+    [key: string]: unknown;
+}
+export declare function migrateConfig(config: MugConfig): SourcesConfig;
+export declare function configNeedsMigration(config: MugConfig): boolean;
+export {};

package/dist/src/connector-migration.js

@@ -0,0 +1,43 @@
+export function migrateConfig(config) {
+    if (config.sources && !config.connections && !config.connectors) {
+        return config.sources;
+    }
+    if (!config.connections && !config.connectors) {
+        return {};
+    }
+    const connections = config.connections ?? {};
+    const connectors = config.connectors ?? {};
+    const sources = {};
+    for (const [name, conn] of Object.entries(connections)) {
+        sources[name] = {
+            ...(conn.auth ? { auth: conn.auth } : {}),
+            ...(conn.baseUrl ? { baseUrl: conn.baseUrl } : {}),
+            syncs: {},
+        };
+    }
+    for (const [connectorName, connector] of Object.entries(connectors)) {
+        const schedule = connector.schedule ?? connector.syncSchedule;
+        const sync = {
+            database: connector.database ?? connectorName,
+            ...(schedule ? { schedule } : {}),
+        };
+        let sourceName;
+        if (connector.connection && sources[connector.connection]) {
+            sourceName = connector.connection;
+        }
+        else if (sources[connectorName]) {
+            sourceName = connectorName;
+        }
+        else {
+            sourceName = connector.connection ?? connectorName;
+            if (!sources[sourceName]) {
+                sources[sourceName] = { syncs: {} };
+            }
+        }
+        sources[sourceName].syncs[connectorName] = sync;
+    }
+    return sources;
+}
+export function configNeedsMigration(config) {
+    return !!(config.connections || config.connectors) && !config.sources;
+}

package/dist/src/connector-parser.d.ts

@@ -0,0 +1,14 @@
+export interface ParsedTable {
+    name: string;
+    primaryKey: string;
+    endpoint?: string;
+    description?: string;
+}
+export interface ParsedSource {
+    name: string;
+    description?: string;
+    database: string;
+    tables: ParsedTable[];
+    baseUrl?: string;
+}
+export declare function parseSourceFile(source: string, fileName: string): ParsedSource | null;