@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/edge/mcp/tools-social.js

@@ -0,0 +1,47 @@
+import { setupSectionNames } from "../../slices/project-templates/setup-sections.js";
+import { choiceBody, linkBody, redditBody, textBody } from "../../slices/social/schema.js";
+// A project's posts to X, LinkedIn, Instagram, TikTok, Reddit and Bluesky, as Copy for YouTube
+// Studio shows them. Agents prepare them; Fill in <site> and posting are the person's.
+export const socialTools = [
+    {
+        name: "get_post_packs",
+        route: "GET /api/social/packs/:projectId",
+        title: "Read the posts for other sites",
+        description: "Copy for YouTube Studio's posts: for each site the project posts to, the text as it goes in (with its count and limit), hashtags, link, media, AI label, when it goes out, warnings and where the post stands. The agent's work ends here: filling a site's form and posting are the person's.",
+    },
+    {
+        name: "set_post_choice",
+        route: "PUT /api/social/packs/:projectId/:platform/choice",
+        title: "Change what a post carries",
+        description: `The project's own settings for one site (platform: x, linkedin, instagram, tiktok, reddit or bluesky): its text source, media, hashtags and link; {off: true} to not post there; null to go back to the template's. A post prompt (text "prompt") is a paid step picked only in the template (Edit template → ${setupSectionNames.youtube}) or in Create, where Save shows its cost. Body: {choice}.`,
+        body: choiceBody,
+    },
+    {
+        name: "edit_post_text",
+        route: "PUT /api/social/packs/:projectId/:platform/text",
+        title: "Edit a post's text",
+        description: "Hand-edits one site's post text. Body: {text: the new text, base: the text you edited from (get_post_packs' generated)}.",
+        body: textBody,
+    },
+    {
+        name: "reset_post_text",
+        route: "DELETE /api/social/packs/:projectId/:platform/text",
+        title: "Drop a post's hand edit",
+        description: "Drops the hand edit of one site's post; the written text comes back.",
+        confirm: "This drops your hand edit of this post for good; the text Slopify wrote comes back.",
+    },
+    {
+        name: "set_reddit_post",
+        route: "PUT /api/social/packs/:projectId/:platform/reddit",
+        title: "Set the Reddit post's fields",
+        description: "The Reddit post's subreddit (without r/), title, flair and kind (link, text or media); platform must be reddit. Body: {reddit: {subreddit, title, flair, kind}}.",
+        body: redditBody,
+    },
+    {
+        name: "set_post_link",
+        route: "PUT /api/social/packs/:projectId/:platform/link",
+        title: "Record a post's link",
+        description: "Marks one site's post as posted with its link (a post the person made by hand, or one the extension missed); null removes the link so the post can be filled again. Body: {url: the post's address | null}.",
+        body: linkBody,
+    },
+];

package/dist/edge/mcp/tools-storage.js

@@ -1,3 +1,6 @@
+import { fullVideoInputSchema, quickShortInputSchema } from "../../slices/onboarding/model.js";
+import { moveFilesBody } from "../http/storage-files.js";
+import { manySchema } from "../http/trash.js";
 import { formBody } from "./route-tool.js";
 const storage = [
     {
@@ -9,6 +12,7 @@ const storage = [
     {
         name: "move_files_folder",
         route: "POST /api/storage/files/move",
+        body: moveFilesBody,
         title: "Move the files folder",
         description: "Body: {target: the new folder's full path; it must be empty or new}.",
         confirm: "This moves every project and backup file to the new folder; Slopify refuses a folder that is not empty.",
@@ -34,6 +38,7 @@ const storage = [
     {
         name: "restore_from_trash_many",
         route: "POST /api/trash/bulk/restore",
+        body: manySchema,
         title: "Restore several from the trash",
         description: "Restore for the ticked rows. Body: {items: [{kind, id}]}.",
     },
@@ -47,6 +52,7 @@ const storage = [
     {
         name: "delete_from_trash_many",
         route: "POST /api/trash/bulk/delete",
+        body: manySchema,
         title: "Delete several for good",
         description: "Delete now for the ticked rows. Body: {items: [{kind, id}]}.",
         confirm: "The projects and every file they produced are removed from disk (deleted schedules keep their run history on Schedules). Nothing removed here can be restored. This cannot be undone.",
@@ -57,23 +63,25 @@ const onboarding = [
         name: "get_onboarding",
         route: "GET /api/onboarding",
         title: "Read the welcome state",
-        description: "Starter packs and what the welcome offers.",
+        description: "Starter templates and what the welcome offers.",
     },
     {
         name: "install_starter_pack",
         route: "POST /api/onboarding/packs/:id",
-        title: "Install a starter pack",
-        description: "Adds a starter pack's prompts and templates.",
+        title: "Install a starter template",
+        description: "Adds a starter template's prompts and templates.",
     },
     {
         name: "make_quick_short",
         route: "POST /api/onboarding/short",
+        body: quickShortInputSchema,
         title: "Make a quick short",
         description: `${formBody("the welcome's Make a short")} It starts a paid run.`,
     },
     {
         name: "make_full_video_draft",
         route: "POST /api/onboarding/full-video",
+        body: fullVideoInputSchema,
         title: "Draft a full video",
         description: formBody("the welcome's Make a full video"),
     },

package/dist/edge/mcp/tools-template-studio.js

@@ -0,0 +1,166 @@
+import { bakeoffStartSchema } from "../../slices/template-studio/bakeoff.js";
+import { studioSettingsSchema } from "../../slices/template-studio/budget.js";
+import { samplesForAllSchema } from "../../slices/template-studio/for-all.js";
+import { markReadySchema } from "../../slices/template-studio/ready.js";
+import { makeSampleSchema, saveStudioSchema } from "../../slices/template-studio/save.js";
+import { sayItAsSchema } from "../../slices/template-studio/say-it-as.js";
+import { fullScriptSchema, topicSchema } from "../../slices/template-studio/topic.js";
+// Edit template (Templates → a template → Edit template). Not the YouTube Studio tools.
+export const templateStudioTools = [
+    {
+        name: "get_template_studio",
+        route: "GET /api/template-studio/:id",
+        title: "Read a template in Edit template",
+        description: "The template's sections with each sample's state (current, making, waiting, needs-fix, stale, off, provided), the sample topic, and which version schedules run. Its checks are read with get_template_checks.",
+    },
+    {
+        name: "get_template_checks",
+        route: "GET /api/template-studio/:id/checks",
+        title: "Read a template's checks",
+        description: "The free checks the template's current version passes before Approve for schedules, each failing one with what is wrong and where it is fixed: keywords filled, providers set up, a voice that is one of yours (Settings → Voices), release times, a known monthly cost, someone to answer each pause.",
+    },
+    {
+        name: "mark_template_ready",
+        route: "POST /api/template-studio/:id/ready",
+        body: markReadySchema,
+        title: "Approve a template for its schedules",
+        description: "Approves the template's newest version (pass it as version) for its schedules, so they run it from their next run on: Edit template's Approve for schedules. Refused, approving nothing, while a check fails or a section's sample isn't current, with each thing to fix (problems). A version already approved is answered again. Until a template's first approval its schedules run its newest version; from then on a schedule runs only a version approved for schedules, saved before Edit template, or carried over from one by Slopify, and each version saved later waits until it is approved.",
+        confirm: "Schedules run this version from their next run, and each version saved later waits until it is approved.",
+    },
+    {
+        name: "get_prompt_anatomy",
+        route: "GET /api/template-studio/:id/anatomy",
+        title: "Read a section's prompt anatomy",
+        description: "One of the prompts a template section sends (section: subject, script, voice, pictures, thumbnail, shorts, upload, reviews; item: the prompt's key from items), cut into segments: the person's own words (yours), their keywords' values (keyword), what Slopify fills itself (slopify) and what settings add (setting). Read from the prompt the sample sent when it was made from these settings.",
+    },
+    {
+        name: "quote_template_save",
+        route: "POST /api/template-studio/:id/quote",
+        title: "Price a template Save's sample",
+        description: 'Prices a sample before anything is spent. Send one of: document (what a Save of this template document would make), topic (a new sample topic, "next-queued" or "fixed": every section) or fullScript (the whole script switched on or off: the script and what follows). It answers the sections it outdates, each step\'s cost, the total high estimate, how many steps have no price, and whether it fits today\'s sample budget. Changes nothing. Pass its high as acknowledgedHigh to save_template_studio.',
+        unrecorded: true,
+    },
+    {
+        name: "save_template_studio",
+        route: "POST /api/template-studio/:id/save",
+        body: saveStudioSchema,
+        title: "Save a template in Edit template",
+        description: 'Saves the template document as its next version. With sample "make" it also makes the paid sample of what changed, which spends money: price it first with quote_template_save and pass that quote\'s high as acknowledgedHigh (and acknowledgedUnknown: true when the quote counts steps with no price). A higher price, an unaccepted unknown one or a sample past today\'s budget is refused with the new quote and nothing is saved. With sample "skip" only the free samples are made. Send the same mutationId to retry the very same Save.',
+    },
+    {
+        name: "make_template_sample",
+        route: "POST /api/template-studio/:id/samples/make",
+        body: makeSampleSchema,
+        title: "Make a template's paid sample again",
+        description: "Queues the paid sample of the template's current version again, which spends money: after it waited (a higher price, steps with no price, today's budget) or failed. Pass the version and the price get_template_studio shows for it as acknowledgedHigh, and acknowledgedUnknown: true to accept steps with no price. A sample that would cost more still waits.",
+    },
+    {
+        name: "set_sample_topic",
+        route: "PUT /api/template-studio/:id/topic",
+        body: topicSchema,
+        title: "Change a template's sample topic",
+        description: 'Changes the topic the template\'s samples are made about and remakes every section\'s paid sample, which spends money: a typed topic, "next-queued" for the next topic one of its schedules has queued, or "fixed" for the topic every sample starts on. Pass the price as acknowledgedHigh (and acknowledgedUnknown: true to accept steps with no price); a higher price, an unaccepted unknown one or one past today\'s budget is refused with the new quote and nothing changes.',
+    },
+    {
+        name: "set_sample_full_script",
+        route: "POST /api/template-studio/:id/full-script",
+        body: fullScriptSchema,
+        title: "Write a template sample's full script",
+        description: "Switches the template's sample between the whole script (fullScript: true) and the outline and first chapter (false), and remakes the script and what is made from it, which spends money. Pass the price as acknowledgedHigh; it is refused with the new quote at a higher price, unaccepted unknown prices or past today's budget.",
+    },
+    {
+        name: "get_sample_pronunciations",
+        route: "GET /api/template-studio/:id/pronunciations",
+        title: "Read the names a template's voice may say wrong",
+        description: "The names the template's sample script says that a voice may get wrong (its Pronunciation Glossary, and words the Pronunciation list (Settings → Voices → Pronunciation) already changes), each with its IPA, the first line it is said in and the alias it has (spokenAs). aliasesOn says whether the template's voice uses the Pronunciation list.",
+    },
+    {
+        name: "quote_say_it_as",
+        route: "POST /api/template-studio/:id/say-it-as/quote",
+        title: "Price saying a word another way",
+        description: "Prices voicing again, with written said as spoken, only the template sample's lines that say it: how many lines, the high estimate, steps with no price and whether it fits today's sample budget. Changes nothing. Pass its high as acknowledgedHigh to say_it_as.",
+        unrecorded: true,
+    },
+    {
+        name: "say_it_as",
+        route: "POST /api/template-studio/:id/say-it-as",
+        body: sayItAsSchema,
+        title: "Say a word another way",
+        description: "Writes a row of the Pronunciation list (Settings → Voices → Pronunciation) (written said as spoken, whole word, any case; it replaces one for the same word) and voices again only the template sample's lines that say it, which spends money: price it first with quote_say_it_as and pass its high as acknowledgedHigh. The alias applies to every project started after it. Refused, writing nothing, at a higher price, with unaccepted unknown prices, past today's budget, or when the template's voice doesn't use aliases.",
+    },
+    {
+        name: "get_template_studio_settings",
+        route: "GET /api/template-studio/settings",
+        title: "Read the template samples' budgets",
+        description: "The most Edit template's samples may spend in one day (dailyBudget, US dollars), whether they may run steps on a CLI plan (samplesUsePlans; off by default, such a sample waits; it applies to designed pieces' samples too), the most designed pieces' template samples may spend in one day (designDailyBudget, $1 by default), and what each spent today and has left (today, designToday).",
+    },
+    {
+        name: "update_template_studio_settings",
+        route: "PUT /api/template-studio/settings",
+        body: studioSettingsSchema,
+        title: "Change the template samples' daily budgets",
+        description: "Sets any of: dailyBudget, the most Edit template's samples may spend in one day, in US dollars (0 to 1000); designDailyBudget, the same for designed pieces' template samples (0 to 1000); samplesUsePlans, whether either may run steps on a Claude Code or Codex plan, which the dollar budgets can't limit. A field left out keeps what it was. A sample that would go over its budget, or needs a plan while plans are off, waits.",
+    },
+    {
+        name: "quote_samples_for_all",
+        route: "POST /api/template-studio/samples-for-all/quote",
+        title: "Price the samples of every template",
+        description: "Prices the paid sample of every template whose newest version has none (or changed since its last one), before anything is spent: each template's high estimate, whether it fits what is left of today's sample budget (spent in name order), the total and a sentence saying how many fit. Changes nothing. Pass its total as acknowledgedTotal to make_samples_for_all.",
+        unrecorded: true,
+    },
+    {
+        name: "make_samples_for_all",
+        route: "POST /api/template-studio/samples-for-all",
+        body: samplesForAllSchema,
+        title: "Make the samples of every template",
+        description: "Makes the paid sample of every template that needs one, which spends money: price them first with quote_samples_for_all and pass its total as acknowledgedTotal (and acknowledgedUnknown: true to accept steps with no price). The ones that fit today's budget are queued; the rest wait, saying so, until tomorrow or a higher budget. A higher total is refused with the new quote and nothing is queued.",
+        confirm: "This spends money on the samples of every template that needs one.",
+    },
+    {
+        name: "make_template_free_samples",
+        route: "POST /api/template-studio/:id/free-samples",
+        title: "Make a template's free samples",
+        description: "Queues the samples made on this computer at no cost for the template's current version: the 30-second video, the loudness before and after, the PDF, and the schedules' cost a month. Read them back with get_template_studio.",
+    },
+    {
+        name: "import_template_pack",
+        route: "POST /api/template-studio/packs/import",
+        title: "Import a template file",
+        description: "Makes a new template from a template file (the .zip Edit template's Export as a file (.zip) made, at most 30 MB): its prompts and intros join Prompts (a name taken by other text comes in as \"<name> (2)\" and the template names that one), its voice is used as it is, and it is not checked in Edit template yet: look its samples over and approve it for schedules (mark_template_ready). A file holding anything that looks like a key, a file a template file never has or a newer format is refused, writing nothing. Answers templateId, the name it got, how many prompts and intros it added and which were renamed, whether Settings → Voices has its voice (voiceKnown; when false, get_template_checks' voice check says what to do) and how many samples it brought.",
+        upload: "multipart",
+    },
+    {
+        name: "get_template_pack_samples",
+        route: "GET /api/template-studio/:id/pack-samples",
+        title: "List the samples a template's file brought",
+        description: "The samples an imported template file came with (role: thumbnail, picture or narration; name; url), shown in Edit template until the template makes its own. Empty for a template that didn't come from a file.",
+    },
+    {
+        name: "quote_bakeoff",
+        route: "POST /api/template-studio/:id/bakeoff/quote",
+        title: "Price comparing models on a template's sample",
+        description: "Prices making one section's sample again on one or two other models (section: script, voice or pictures; models: [{provider, model}], not the model the section uses now, which is compared from the current sample; voice models only of the template's voice provider). Needs a current sample of the newest version. Answers each model's high estimate, steps with no price, the total, today's sample budget and whether it fits. Changes nothing. Pass its high as acknowledgedHigh to start_bakeoff.",
+        unrecorded: true,
+    },
+    {
+        name: "start_bakeoff",
+        route: "POST /api/template-studio/:id/bakeoff",
+        body: bakeoffStartSchema,
+        title: "Compare models on a template's sample",
+        description: "Makes the section's sample again on each model, each on a hidden copy of the template's sample with only that section's work started, which spends money: price it first with quote_bakeoff and pass its high as acknowledgedHigh (and acknowledgedUnknown: true to accept steps with no price). A higher total, an unaccepted unknown price or a total past today's budget is refused with the new quote, starting nothing. The template doesn't change: read the results with get_bakeoff, then switch the model with save_template_studio and discard the copies with discard_bakeoff.",
+        confirm: "This spends money making the section's sample again on each model.",
+    },
+    {
+        name: "get_bakeoff",
+        route: "GET /api/template-studio/:id/bakeoff",
+        title: "Read a template's model bake-off",
+        description: "The template's bake-off, or null: its section, the version it was made for (stale when the template was saved since), its state (queued, making, done, held with why, failed with why) and one entry per model, the one in use first (state current), each with what it was charged (cost, US dollars), how long its section took (seconds), its failure, and what it made (outputs; article: the script's opening).",
+    },
+    {
+        name: "discard_bakeoff",
+        route: "DELETE /api/template-studio/:id/bakeoff",
+        title: "Discard a template's model bake-off",
+        description: "Removes the bake-off's copies and what they made. What they were charged today still counts against the sample budget. Refused while a copy still has work going.",
+        confirm: "The bake-off's copies and what they made are removed.",
+    },
+];

package/dist/edge/mcp/tools.js

@@ -1,4 +1,5 @@
 import { channelTools } from "./tools-channels.js";
+import { designTools } from "./tools-designs.js";
 import { libraryTools } from "./tools-library.js";
 import { planningTools } from "./tools-planning.js";
 import { projectTools } from "./tools-projects.js";
@@ -6,16 +7,21 @@ import { publishingTools } from "./tools-publishing.js";
 import { runTools } from "./tools-runs.js";
 import { scheduleTools } from "./tools-schedules.js";
 import { setupTools } from "./tools-setup.js";
+import { socialTools } from "./tools-social.js";
 import { storageTools } from "./tools-storage.js";
+import { templateStudioTools } from "./tools-template-studio.js";
 // Every API route an agent may call, as a tool; `excluded-routes.ts` names the rest and why.
 export const routeTools = [
     ...projectTools,
     ...publishingTools,
+    ...socialTools,
     ...runTools,
     ...planningTools,
     ...scheduleTools,
     ...channelTools,
+    ...designTools,
     ...libraryTools,
     ...setupTools,
     ...storageTools,
+    ...templateStudioTools,
 ];

package/dist/edge/remote-access/cli.js

@@ -0,0 +1,71 @@
+import { execFile } from "node:child_process";
+// Every command Slopify sends. Serve only: Funnel puts an address on the public internet, and
+// Slopify has no login and holds API keys, so no path through Slopify may ever reach it.
+export const tailscaleCommands = {
+    status: () => ["status", "--json"],
+    serveStatus: () => ["serve", "status", "--json"],
+    serveOn: (httpsPort, target) => [
+        "serve",
+        "--bg",
+        "--yes",
+        `--https=${httpsPort}`,
+        target,
+    ],
+    serveOff: (httpsPort) => ["serve", "--yes", `--https=${httpsPort}`, "off"],
+};
+const allowed = new Set(["status", "serve"]);
+// The last line of defence: a command that names Funnel, or isn't one of the above, never runs.
+export function assertServeOnly(args) {
+    const [command] = args;
+    if (command === undefined || !allowed.has(command))
+        throw new Error(`Slopify only runs tailscale status and tailscale serve, not "${command}".`);
+    if (args.some((arg) => /funnel/iu.test(arg)))
+        throw new Error("Slopify never turns on Tailscale Funnel.");
+}
+export function guarded(run) {
+    return async (args) => {
+        assertServeOnly(args);
+        return run(args);
+    };
+}
+// Where the command is when it isn't on PATH: the macOS app bundle and the Windows installer.
+export function tailscaleCandidates(platform) {
+    if (platform === "darwin")
+        return ["tailscale", "/Applications/Tailscale.app/Contents/MacOS/Tailscale"];
+    if (platform === "win32")
+        return ["tailscale", "C:\\Program Files\\Tailscale\\tailscale.exe"];
+    return ["tailscale"];
+}
+function execOnce(file, args, timeoutMs) {
+    return new Promise((resolve) => {
+        execFile(file, [...args], { windowsHide: true, timeout: timeoutMs, encoding: "utf8", maxBuffer: 4 * 1024 * 1024 }, (error, stdout, stderr) => {
+            if (error === null) {
+                resolve({ code: 0, stdout, stderr, missing: false, timedOut: false });
+                return;
+            }
+            const missing = error.code === "ENOENT";
+            const timedOut = error.killed === true && error.signal !== null;
+            resolve({
+                code: typeof error.code === "number" ? error.code : 1,
+                stdout,
+                stderr: stderr || error.message,
+                missing,
+                timedOut,
+            });
+        });
+    });
+}
+// ceiling: a status or serve call answers within a second on a healthy machine; a hung
+// daemon must not hold a request, so each call is cut off.
+export function nodeTailscaleRun(platform, timeoutMs = 10_000) {
+    const candidates = tailscaleCandidates(platform);
+    return guarded(async (args) => {
+        let last;
+        for (const file of candidates) {
+            last = await execOnce(file, args, timeoutMs);
+            if (!last.missing)
+                return last;
+        }
+        return last ?? { code: 127, stdout: "", stderr: "", missing: true, timedOut: false };
+    });
+}

package/dist/edge/remote-access/model.js

@@ -0,0 +1,32 @@
+// What Settings → Remote access shows. The web client imports this file, so it stays
+// free of Node imports.
+export const remoteAccessStates = [
+    // The switch is off: Slopify answers only on this computer.
+    "off",
+    // Tailscale serves Slopify's address on the tailnet.
+    "on",
+    // Slopify runs in Docker; the switch needs Slopify started on the computer itself.
+    "docker",
+    "not-installed",
+    "not-running",
+    "signed-out",
+    // The tailnet has no HTTPS certificates (MagicDNS and HTTPS in the admin console).
+    "https-off",
+    // Tailscale refused this user (Linux: not the operator).
+    "denied",
+    // Another serve setting already uses the HTTPS port.
+    "port-taken",
+    // Tailscale Funnel was found on Slopify's address; Slopify removed its own setting.
+    "funnel",
+    // The switch is on, but Slopify's address isn't in Tailscale right now.
+    "not-applied",
+    "failed",
+];
+export const defaultHttpsPort = 443;
+// The ports Slopify offers when one is taken, in order. Any port works for Serve; these are the
+// ones Tailscale's own documentation uses.
+export const httpsPortChoices = [443, 8443, 10000];
+// Settings rows: the switch as the person set it, and the exact serve handler Slopify added
+// (removed again only when it is still exactly that).
+export const remoteAccessKey = "remote-access";
+export const remoteAccessAppliedKey = "remote-access.applied";

package/dist/edge/remote-access/rules.js

@@ -0,0 +1,207 @@
+import { z } from "zod";
+import { httpsPortChoices } from "./model.js";
+export const installLink = "https://tailscale.com/download";
+export const dnsAdminLink = "https://login.tailscale.com/admin/dns";
+const statusShape = z
+    .object({
+    BackendState: z.string(),
+    Self: z
+        .object({ DNSName: z.string().optional(), UserID: z.number().optional() })
+        .loose()
+        .optional(),
+    User: z
+        .record(z.string(), z.object({ LoginName: z.string().optional() }).loose())
+        .nullable()
+        .optional(),
+    CertDomains: z.array(z.string()).nullable().optional(),
+})
+    .loose();
+const handlerShape = z.object({ Proxy: z.string().optional() }).loose();
+const webShape = z.object({ Handlers: z.record(z.string(), handlerShape).optional() }).loose();
+const tcpShape = z.object({ HTTPS: z.boolean().optional(), HTTP: z.boolean().optional() }).loose();
+const configShape = z
+    .object({
+    TCP: z.record(z.string(), tcpShape).nullable().optional(),
+    Web: z.record(z.string(), webShape).nullable().optional(),
+    AllowFunnel: z.record(z.string(), z.boolean()).nullable().optional(),
+})
+    .loose();
+const serveShape = configShape
+    .extend({ Foreground: z.record(z.string(), configShape).nullable().optional() })
+    .loose();
+const deniedPattern = /access denied|permission denied|operator|must be root|not permitted/iu;
+const notRunningPattern = /failed to connect|doesn't appear to be running|is tailscaled running|connection refused|no such file or directory|cannot connect/iu;
+// A failed command's own reason, in the person's words.
+export function problemOf(result, platform) {
+    if (result.missing)
+        return {
+            state: "not-installed",
+            summary: "Tailscale isn't installed on this computer, so Slopify can't open it on your other devices.",
+            fix: "Install Tailscale from tailscale.com/download, sign in, then press Check again.",
+            link: installLink,
+        };
+    if (result.timedOut)
+        return {
+            state: "failed",
+            summary: "Tailscale didn't answer within 10 seconds.",
+            fix: "Make sure the Tailscale app or service is running (open the Tailscale app, or run tailscale status in a terminal), then press Check again.",
+            link: null,
+        };
+    const text = `${result.stderr}\n${result.stdout}`.trim();
+    if (deniedPattern.test(text))
+        return deniedProblem(platform);
+    if (notRunningPattern.test(text))
+        return notRunningProblem();
+    return {
+        state: "failed",
+        summary: `Tailscale refused: ${firstLine(text) || `it stopped with code ${result.code}`}.`,
+        fix: "Run tailscale status in a terminal to see what Tailscale reports, fix that, then press Check again.",
+        link: null,
+    };
+}
+export function deniedProblem(platform) {
+    return {
+        state: "denied",
+        summary: "Tailscale won't let your user change its serve settings.",
+        fix: platform === "linux"
+            ? "On Linux, allow your user once: run sudo tailscale set --operator=$USER in a terminal, then press Check again."
+            : "Open the Tailscale app as the user who signed in to it, then press Check again.",
+        link: null,
+    };
+}
+function notRunningProblem() {
+    return {
+        state: "not-running",
+        summary: "Tailscale is installed but not running.",
+        fix: "Open the Tailscale app and connect, or run tailscale up in a terminal, then press Check again.",
+        link: null,
+    };
+}
+function firstLine(text) {
+    return (text.split("\n").find((line) => line.trim() !== "") ?? "").trim().replace(/\.$/u, "");
+}
+// Which machine this is, or why Tailscale can't serve it yet.
+export function machineOf(stdout) {
+    let parsed;
+    try {
+        parsed = statusShape.parse(JSON.parse(stdout));
+    }
+    catch {
+        return {
+            state: "failed",
+            summary: "Slopify couldn't read tailscale status --json.",
+            fix: "Update Tailscale to a current version (tailscale.com/download), then press Check again.",
+            link: installLink,
+        };
+    }
+    if (parsed.BackendState === "NeedsLogin" || parsed.BackendState === "NeedsMachineAuth")
+        return {
+            state: "signed-out",
+            summary: parsed.BackendState === "NeedsMachineAuth"
+                ? "This computer is waiting for approval in your tailnet."
+                : "Tailscale is signed out on this computer.",
+            fix: parsed.BackendState === "NeedsMachineAuth"
+                ? "Approve this computer in the Tailscale admin console (login.tailscale.com/admin/machines), then press Check again."
+                : "Open the Tailscale app and sign in, or run tailscale up in a terminal, then press Check again.",
+            link: null,
+        };
+    if (parsed.BackendState !== "Running")
+        return notRunningProblem();
+    const dnsName = (parsed.Self?.DNSName ?? "").replace(/\.$/u, "");
+    const certs = parsed.CertDomains ?? [];
+    if (dnsName === "" || !certs.includes(dnsName))
+        return {
+            state: "https-off",
+            summary: "Your tailnet has no HTTPS certificates, so Tailscale can't give Slopify an https address.",
+            fix: "In the Tailscale admin console open DNS (login.tailscale.com/admin/dns), turn on MagicDNS if it is off, then under HTTPS Certificates press Enable HTTPS. Then press Check again.",
+            link: dnsAdminLink,
+        };
+    const userId = parsed.Self?.UserID;
+    const owner = userId === undefined ? undefined : parsed.User?.[String(userId)]?.LoginName;
+    return owner === undefined || owner === "" ? { dnsName } : { dnsName, owner };
+}
+export function isProblem(value) {
+    return "state" in value;
+}
+export function parseServeStatus(stdout) {
+    const text = stdout.trim();
+    if (text === "")
+        return {};
+    try {
+        return serveShape.parse(JSON.parse(text));
+    }
+    catch {
+        return undefined;
+    }
+}
+export const hostPort = (dnsName, httpsPort) => `${dnsName}:${httpsPort}`;
+// The address a browser opens; 443 is https's own port, so it isn't written.
+export function addressOf(dnsName, httpsPort) {
+    return httpsPort === 443 ? `https://${dnsName}` : `https://${dnsName}:${httpsPort}`;
+}
+const normal = (url) => url.replace(/\/+$/u, "");
+function configsOf(status) {
+    return [status, ...Object.values(status.Foreground ?? {})];
+}
+// What uses an HTTPS port on this machine now, in the background config or a foreground
+// `tailscale serve` still running in someone's terminal.
+export function portUse(status, dnsName, httpsPort) {
+    const key = hostPort(dnsName, httpsPort);
+    const used = configsOf(status).filter((config) => config.TCP?.[String(httpsPort)] !== undefined || config.Web?.[key] !== undefined);
+    const [only] = used;
+    if (only === undefined)
+        return { kind: "free" };
+    const handlers = Object.entries(only.Web?.[key]?.Handlers ?? {});
+    const [first] = handlers;
+    if (used.length === 1 &&
+        only.TCP?.[String(httpsPort)]?.HTTPS === true &&
+        handlers.length === 1 &&
+        first !== undefined &&
+        first[0] === "/" &&
+        first[1].Proxy !== undefined)
+        return {
+            kind: "proxy",
+            target: normal(first[1].Proxy),
+            funnel: configsOf(status).some((config) => config.AllowFunnel?.[key] === true),
+        };
+    return {
+        kind: "other",
+        what: handlers.length === 0
+            ? "a TCP forwarder"
+            : handlers
+                .map(([path, handler]) => `${path} → ${handler.Proxy ?? "a file or text"}`)
+                .join(", "),
+    };
+}
+export function sameTarget(a, b) {
+    return normal(a) === normal(b);
+}
+export function freePort(status, dnsName, except) {
+    return (httpsPortChoices.find((port) => port !== except && portUse(status, dnsName, port).kind === "free") ?? null);
+}
+export function portTakenProblem(httpsPort, use, target, suggestedPort) {
+    const instead = suggestedPort === null
+        ? "Choose another HTTPS port below"
+        : `Press Use port ${suggestedPort} to give Slopify its own address`;
+    const what = use.kind === "proxy" ? `a proxy to ${use.target}` : use.what;
+    const yours = use.kind === "proxy" && sameTarget(use.target, target)
+        ? " It already points at this Slopify, but you set it up outside Slopify, so Slopify leaves it alone."
+        : "";
+    return {
+        state: "port-taken",
+        summary: `HTTPS port ${httpsPort} on your tailnet address is already used by another Tailscale serve setting (${what}).${yours}`,
+        fix: `${instead}, or remove the other setting with tailscale serve --https=${httpsPort} off and press Check again.`,
+        link: null,
+    };
+}
+export function serveRefusedProblem(result, platform) {
+    const text = `${result.stderr}\n${result.stdout}`;
+    if (!result.missing && !result.timedOut && /https|cert/iu.test(text) && !deniedPattern.test(text))
+        return {
+            state: "https-off",
+            summary: `Tailscale couldn't give Slopify an https address: ${firstLine(text)}.`,
+            fix: "In the Tailscale admin console open DNS (login.tailscale.com/admin/dns), turn on MagicDNS if it is off, then under HTTPS Certificates press Enable HTTPS. Then press Check again.",
+            link: dnsAdminLink,
+        };
+    return problemOf(result, platform);
+}