sitevision-cli 1.0.0-beta.9 → 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,138 @@
+# Changelog
+
+## 1.0.0
+
+First stable release. Everything from the betas is in, see the entries below.
+
+- `svc --debug` (or `SVC_DEBUG=1`) writes a log of everything svc does during
+  the run: each action, task and its output, request to Sitevision, child
+  process, config change, prompt and keychain lookup. The path is printed on
+  exit. Passwords, tokens and cookies are never written; the site, username
+  and file paths are, so read it before attaching it to a bug report.
+- Bug reports and feature requests have forms on GitHub.
+
+## 1.0.0-beta.33
+
+- **Breaking:** `--token` and `--cookie` are removed, since credentials on the
+  command line end up in shell history. Use `SITEVISION_ACCESS_TOKEN` or
+  `SITEVISION_SESSION_COOKIE` instead.
+- **Breaking:** an unknown flag is now an error (exit code 2), so a misspelt
+  `--production` never turns into a dev deploy.
+- `svc build`, `svc sign` and `svc deploy` work without a terminal. They print
+  their log line by line and exit on their own with a proper exit code: 0 on
+  success, 1 on failure, 130 when a prompt is cancelled. `svc dev` and
+  `svc watch` no longer crash when stdin is a pipe.
+- New flags: `--no-zip` for `build`, and the short forms `-s`, `-f`, `-p` and
+  `-a`.
+- Global settings in `~/.config/sitevision-cli/config.json`: a default signing
+  user and certificate for every project that does not set its own, and
+  switches for the update check and the addon name warning. Edit them with `,`
+  in the shell, which now shows a description of each setting and opens from
+  anywhere, or run `svc setup-signing --global`. A file that does not parse is
+  reported and left alone.
+- The Config tab marks the addon name with `≠ manifest` when it matches none
+  of the manifest's names. Nothing is changed for you; the two are different
+  things and `svc` only points the difference out.
+- The manifest's name and description always have a Swedish row in the Config
+  tab. Filling it in on a plain name keeps the old text as the English one.
+- In a workspace, an environment's addon name is stored per app. Setting it
+  for one app no longer leaks into the others.
+- `svc` names the missing setting when the deploy config is incomplete,
+  instead of posting to "undefined".
+- A production deploy with `--activate` fails if the activation did not
+  happen, and the confirmation names the addon it deploys to.
+- OAuth2 requires https and a token endpoint on the site's own domain. A
+  refresh token is only thrown away when the site rejects it, not on a network
+  error. An expired session cookie is removed so the next deploy asks for a
+  new login.
+- A plaintext password in `.dev_properties.json` is moved to the keychain when
+  the file is saved, and `svc` says so when the keychain cannot store a secret.
+  `SVC_NO_KEYCHAIN=1` turns the keychain off for CI.
+- `svc dev` with a project's own webpack config no longer deploys a half-built
+  zip when several files change at once.
+- Builds work when dependencies are hoisted to the workspace root, a
+  `manifest.json` in the project root is picked up, file names with å, ä and ö
+  survive in the zip, and `SITEVISION_APP_ID_PREFIX`/`_SUFFIX` apply to build,
+  sign and deploy alike.
+- A broken app in a workspace is skipped with a message instead of stopping
+  the shell. The shell asks before quitting during app creation, the PROD
+  badge survives a narrow terminal, Esc cancels a confirm, and Ctrl-modified
+  keys never fire a shortcut.
+- The update check is skipped without a terminal and when `CI` is set.
+- Updated user guides in English and Swedish.
+
+## 1.0.0-beta.32
+
+- Sitevision CLI can now create new apps. **New app** in the command palette
+  runs Sitevision's own `create-sitevision-app` as a managed experience and
+  guides you through the setup: pick a name and a folder, then answer the
+  tool's questions right in `svc`. What your workspace already knows (domain,
+  site name, username) is filled in for you, and passwords never end up in a
+  file.
+- When the app is created, `svc` fills in its manifest (the name, plus author
+  and help URL from the workspace's `package.json`) and offers to create the
+  addon on the site, so the app is ready for its first deploy.
+- If the tool cannot be run this way, `svc` hands it the terminal and picks up
+  again when it is done.
+- The Config tab has a MANIFEST section for editing `manifest.json`: id,
+  version, name, description, author and help URL, one row per language for
+  localized fields. Comments and formatting in the file are kept.
+- `y` (sync `package.json`) now also mirrors the manifest's `version`,
+  `description` and `author` into the app's `package.json`. An app whose
+  `package.json` lacks them shows as out of sync until `y` is pressed.
+
+## 1.0.0-beta.31
+
+- The help panel (`?`) now starts with a short guide to the pane you are in:
+  what it shows, how the values relate, and which keys apply. The Config guide
+  explains how local, shared and workspace settings layer on top of each
+  other. The panel scrolls when it does not fit.
+- Updated dependencies.
+
+## 1.0.0-beta.30
+
+- Dev and watch no longer rebuild on file events that change nothing, such as
+  editor metadata, swap files or `.DS_Store`. Ignored events are logged as
+  warnings so a stray trigger can be traced.
+- The log names the event and path of the file that started a rebuild, for
+  example `change src/index.tsx`.
+
+## 1.0.0-beta.29
+
+- After an update, the shell opens What's new with the changes since the
+  version you last ran.
+
+## 1.0.0-beta.28
+
+## 1.0.0-beta.27
+
+- Popups float over the screen instead of replacing the content pane: the
+  command palette, settings, addon picker, confirmations and prompts.
+- `?` opens a help panel with every key, plus the keys for the current tab.
+- What's new in the command palette shows this changelog.
+
+## 1.0.0-beta.26
+
+- No functional changes.
+
+## 1.0.0-beta.25
+
+- Deploying to an addon that does not exist yet now offers to create it and
+  deploy again. If the addon list cannot be read, the error suggests logging in
+  again instead, since an expired session fails the same way.
+- A Create addon action appears in the command palette when a deploy has found
+  the addon missing.
+- Creating a RESTApp or MCPServer addon no longer sends a category, which only
+  WebApp and widget addons use.
+
+## 1.0.0-beta.24
+
+- Deploying to a non-production environment uploads the signed zip when it is at
+  least as new as the build. The log names the zip that was uploaded.
+- `x` in the Log tab wraps long lines immediately, and wrapped lines no longer
+  push the newest line out of view.
+- Keys: switching environment moved from `E` to `v`, and refreshing versions
+  from `R` to `r`. Tab in the Config form moves between fields without leaving
+  the form.
+- The bottom bar now shows force deploy (`P`), stop, config, login and settings.
+- Running commands are stopped when `svc` exits.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rasmus Söderström
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli.js

@@ -1,22 +1,29 @@
 #!/usr/bin/env node
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { render } from 'ink';
 import { Text, Box } from 'ink';
 import meow from 'meow';
 import { readFileSync } from 'node:fs';
-import App from './app.js';
+import path from 'node:path';
+import os from 'node:os';
+import { runningTasks } from './utils/tasks.js';
+import { killAllChildren } from './utils/process-runner.js';
+import { Shell } from './shell/Shell.js';
 import { getCommand } from './commands/index.js';
-import { requireProject, migrateLegacyPassword, } from './utils/project-detection.js';
+import { requireProject, detectProject, migrateLegacyPassword, } from './utils/project-detection.js';
+import { discoverApps } from './utils/workspace.js';
 import { promptYesNo } from './utils/password-prompt.js';
 import { checkForUpdate } from './utils/version-check.js';
-import { isFirstRun, markFirstRunComplete, getLastSeenVersion, setLastSeenVersion, } from './utils/config.js';
+import { isFirstRun, markFirstRunComplete, getLastSeenVersion, setLastSeenVersion, getSettings, configProblem, settingsFile, } from './utils/config.js';
+import { setLanguage } from './utils/i18n.js';
+import { debug, enableDebug, errorText, say } from './utils/debug.js';
 import { WelcomeScreen } from './components/WelcomeScreen.js';
 import { AnimatedLogo } from './components/AnimatedLogo.js';
 import { printBranding, BIG_LOGO, BIG_LOGO_WIDTH, SMALL_LOGO, SMALL_LOGO_WIDTH, } from './utils/branding.js';
 const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
 const cli = meow(`
 	Usage
-	  $ svc                    Start interactive menu
+	  $ svc                    Open the interactive shell (app or workspace)
 	  $ svc <command> [options]
 
 	Commands
@@ -26,13 +33,26 @@ const cli = meow(`
 	  sign          Sign the app for production deployment
 	  deploy        Deploy the application
 	  info          Show project information
+	  setup-signing Store the signing username and certificate
 
 	Options
-	  --help        Show this help message
-	  --version     Show version number
+	  --signed, -s      dev/watch: sign after each build
+	  --force, -f       deploy: overwrite the existing addon version
+	  --production, -p  deploy: upload the signed zip to production
+	  --activate, -a    deploy: activate after a production deploy
+	  --no-zip          build: skip the zip archive
+	  --global          setup-signing: save for every project on this machine
+	  --minimal         Shell: compact layout for small terminals
+	  --debug           Write a log of every action to debug.log (or SVC_DEBUG=1)
+	  --help            Show this help message
+	  --version         Show version number
+
+	Credentials for CI come from the environment: SITEVISION_DEPLOY_PASSWORD,
+	SITEVISION_ACCESS_TOKEN or SITEVISION_SESSION_COOKIE.
 
 	Examples
-	  $ svc                     # Interactive menu
+	  $ svc                     # Shell: run inside an app, or at the repo root
+	  $ svc --minimal           # Shell without the sidebar, for a small pane
 	  $ svc dev
 	  $ svc dev --signed
 	  $ svc watch
@@ -43,9 +63,20 @@ const cli = meow(`
 	  $ svc info
 `, {
     importMeta: import.meta,
+    allowUnknownFlags: false,
     flags: {
         signed: {
             type: 'boolean',
+            shortFlag: 's',
+            default: false,
+        },
+        zip: {
+            type: 'boolean',
+            default: true,
+        },
+        activate: {
+            type: 'boolean',
+            shortFlag: 'a',
             default: false,
         },
         force: {
@@ -58,15 +89,34 @@ const cli = meow(`
             shortFlag: 'p',
             default: false,
         },
-        token: {
-            type: 'string',
+        minimal: {
+            type: 'boolean',
+            default: false,
+        },
+        global: {
+            type: 'boolean',
+            default: false,
         },
-        cookie: {
-            type: 'string',
+        debug: {
+            type: 'boolean',
+            default: false,
         },
     },
 });
 const [commandName, ...args] = cli.input;
+const settings = getSettings();
+if (cli.flags.debug || process.env['SVC_DEBUG']) {
+    const file = enableDebug(path.dirname(settingsFile()));
+    process.on('exit', code => {
+        debug('exit', `code ${code}`);
+        process.stderr.write(`\x1b[2mDebug log: ${file}\x1b[0m\n`);
+    });
+    const on = Object.entries(cli.flags)
+        .filter(([, v]) => v === true)
+        .map(([k]) => `--${k}`);
+    debug('start', `svc ${pkg.version} node ${process.version} ${process.platform} ${process.arch} ${[commandName ?? '(shell)', ...args, ...on].join(' ')}`);
+}
+setLanguage(settings.language);
 const CYAN = '\x1b[36m';
 const BOLD = '\x1b[1m';
 const DIM = '\x1b[2m';
@@ -95,8 +145,27 @@ function printMasthead(version) {
         `${spaces(gap)}${DIM}${right}${RESET}${spaces(padding)}${CYAN}│${RESET}`);
     console.log(`${CYAN}╰${border}╯${RESET}`);
 }
+/**
+ * Stop every running task and kill leftover child processes. In raw mode Ink
+ * reads Ctrl+C as a keypress, so no SIGINT reaches anything else. Exits when
+ * there was work to stop (or on a signal); otherwise the process ends on its
+ * own, so a command's last output is never cut off.
+ */
+function shutdown(code) {
+    const busy = runningTasks();
+    for (const task of busy)
+        task.stop();
+    const killed = killAllChildren();
+    if (busy.length > 0 || killed > 0 || code !== undefined)
+        process.exit(code);
+}
+function fail(message, hint) {
+    debug('out', `Error: ${message}`);
+    render(_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "red", children: ["Error: ", message] }), _jsx(Text, { dimColor: true, children: hint })] }));
+    process.exit(1);
+}
 // Pick the widest wordmark that fits the terminal, or undefined if even the
-// compact one would wrap (caller then falls back to the static masthead).
+// compact one would wrap.
 function pickIntroArt(columns) {
     if (columns >= BIG_LOGO_WIDTH)
         return BIG_LOGO;
@@ -111,7 +180,64 @@ async function playIntro(art) {
         app.waitUntilExit().then(() => resolve(), () => resolve());
     });
 }
+// Run the full-screen shell on the alternate screen buffer so the scrollback
+// is untouched, and restore it on exit. The animated wordmark plays first,
+// inside the same buffer, when the terminal is wide enough for it.
+async function runShell(apps, workspaceRoot, updatedFrom, skipped = []) {
+    process.stdout.write('\x1b[?1049h\x1b[H');
+    // Also leave the alternate screen when a signal exits past the finally.
+    process.prependOnceListener('exit', () => process.stdout.write('\x1b[?1049l'));
+    // A crash outside React would print into the alternate screen and vanish
+    // with it: leave it first, then report.
+    const crash = (error) => {
+        process.stdout.write('\x1b[?1049l');
+        debug('crash', errorText(error));
+        console.error('svc crashed:', error);
+        shutdown(1);
+    };
+    process.once('uncaughtException', crash);
+    process.once('unhandledRejection', crash);
+    try {
+        const art = process.stdin.isTTY && settings.introAnimation && !cli.flags.minimal
+            ? pickIntroArt(process.stdout.columns ?? 0)
+            : undefined;
+        if (art) {
+            await playIntro(art);
+            process.stdout.write('\x1b[2J\x1b[H');
+        }
+        // A handover unmounts the shell, runs its job on the normal screen with
+        // the terminal to itself, and starts the shell again.
+        for (;;) {
+            let job;
+            const app = render(_jsx(Shell, { apps: apps, workspaceRoot: workspaceRoot, version: pkg.version, minimal: cli.flags.minimal, updatedFrom: updatedFrom, skipped: skipped, handover: next => {
+                    job = next;
+                    app.unmount();
+                } }));
+            // eslint-disable-next-line no-await-in-loop
+            await app.waitUntilExit();
+            if (!job)
+                break;
+            process.stdout.write('\x1b[?1049l');
+            // eslint-disable-next-line no-await-in-loop
+            await job();
+            if (workspaceRoot) {
+                skipped = [];
+                apps = discoverApps(workspaceRoot, skipped);
+            }
+            updatedFrom = undefined;
+            process.stdout.write('\x1b[?1049h\x1b[2J\x1b[H');
+        }
+    }
+    finally {
+        process.stdout.write('\x1b[?1049l');
+    }
+}
 async function main() {
+    for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+        process.on(signal, () => {
+            shutdown(128 + os.constants.signals[signal]);
+        });
+    }
     // On the very first run we show a dedicated welcome screen instead of the
     // masthead, so the branding is the moment. Only when stdin is a TTY — the
     // welcome is interactive and would hang in CI / piped input.
@@ -122,106 +248,104 @@ async function main() {
     // silently rather than claiming an update happened.
     const lastSeen = getLastSeenVersion();
     const isUpdate = !firstRun && lastSeen !== undefined && lastSeen !== pkg.version;
-    // On the plain interactive `svc` (no command), play the animated wordmark
-    // instead of the static masthead — sized to the terminal. Only on a TTY so it
-    // doesn't run in CI / piped input.
-    const introEligible = !firstRun && !isUpdate && !commandName && Boolean(process.stdin.isTTY);
-    const introArt = introEligible
-        ? pickIntroArt(process.stdout.columns ?? 0)
-        : undefined;
     if (!firstRun) {
-        if (isUpdate) {
+        // The shell shows the changelog itself; only direct commands get a banner.
+        if (isUpdate && commandName) {
             printBranding();
-            console.log(`\x1b[32m\n  ✨ Updated to v${pkg.version}\x1b[0m \x1b[2m(from v${lastSeen})\x1b[0m\n`);
+            say(`\x1b[32m\n  ✨ Updated to v${pkg.version}\x1b[0m \x1b[2m(from v${lastSeen})\x1b[0m\n`);
         }
-        else if (!introArt) {
+        else if (commandName) {
             printMasthead(pkg.version);
         }
         // Record the current version so the banner shows once per upgrade.
         setLastSeenVersion(pkg.version);
+        if (configProblem()) {
+            say(`\x1b[33m  ${settingsFile()} does not parse and is ignored: ${configProblem()}\x1b[0m`);
+        }
         // Check npm for a newer published release.
-        const latestVersion = await checkForUpdate(pkg.name, pkg.version);
+        const latestVersion = settings.updateCheck && process.stdout.isTTY && !process.env['CI']
+            ? await checkForUpdate(pkg.name, pkg.version)
+            : null;
         if (latestVersion) {
-            console.log(`\x1b[33m  ↑ update available: ${pkg.version} → ${latestVersion}  (run: npm i -g ${pkg.name})\x1b[0m`);
+            say(`\x1b[33m  ↑ update available: ${pkg.version} → ${latestVersion}  (run: npm i -g ${pkg.name})\x1b[0m`);
         }
     }
-    // Check if we're in a Sitevision project
-    const project = (() => {
+    // No command: the shell. Inside an app it is single-app mode; anywhere
+    // above one or more apps it is workspace mode.
+    if (!commandName) {
+        let project = null;
         try {
-            return requireProject();
+            project = detectProject();
         }
         catch (error) {
-            render(_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "red", children: ["Error: ", error.message] }), _jsx(Text, { dimColor: true, children: "Make sure you're in a Sitevision project directory" })] }));
-            process.exit(1);
+            fail(error.message, 'Fix the manifest and try again');
         }
-    })();
-    // --token / --cookie override the resolved bearer token / session cookie for
-    // this run (manual / CI path, alongside SITEVISION_ACCESS_TOKEN and
-    // SITEVISION_SESSION_COOKIE).
-    if (cli.flags.token || cli.flags.cookie) {
-        if (project.devProperties) {
-            if (cli.flags.token) {
-                project.devProperties.accessToken = cli.flags.token;
-            }
-            if (cli.flags.cookie) {
-                project.devProperties.sessionCookie = cli.flags.cookie;
+        if (!project) {
+            const skipped = [];
+            const apps = discoverApps(process.cwd(), skipped);
+            if (apps.length === 0) {
+                fail('No Sitevision apps found here.', skipped[0] ??
+                    'Run svc inside an app directory (manifest.json) or at the root of a repo that contains apps.');
             }
+            await runShell(apps, process.cwd(), isUpdate ? lastSeen : undefined, skipped);
+            shutdown();
+            return;
         }
-        else {
-            console.log('\x1b[33m--token/--cookie needs a .dev_properties.json (domain, site, addon) to deploy against.\x1b[0m');
+        if (firstRun) {
+            await new Promise(resolve => {
+                const app = render(_jsx(WelcomeScreen, { project: project, onComplete: () => {
+                        markFirstRunComplete();
+                        setLastSeenVersion(pkg.version);
+                        app.unmount();
+                    } }));
+                app.waitUntilExit().then(() => resolve(), () => resolve());
+            });
         }
-    }
-    // First run: show the welcome (branding + optional signing-password save),
-    // then continue to the normal flow once the user dismisses it.
-    if (firstRun) {
-        await new Promise(resolve => {
-            const app = render(_jsx(WelcomeScreen, { project: project, onComplete: () => {
-                    markFirstRunComplete();
-                    setLastSeenVersion(pkg.version);
-                    app.unmount();
-                } }));
-            app.waitUntilExit().then(() => resolve(), () => resolve());
-        });
-    }
-    // If no command, show interactive menu (with the animated intro first when
-    // the terminal can fit it).
-    if (!commandName) {
-        if (introArt) {
-            await playIntro(introArt);
-        }
-        render(_jsx(App, { project: project }));
+        await runShell([project], undefined, isUpdate ? lastSeen : undefined);
+        shutdown();
         return;
     }
+    // Check if we're in a Sitevision project
+    const project = (() => {
+        try {
+            return requireProject();
+        }
+        catch (error) {
+            return fail(error.message, "Make sure you're in a Sitevision project directory");
+        }
+    })();
     // Get the command
     const command = getCommand(commandName);
     if (!command) {
+        debug('out', `Unknown command: ${commandName}`);
         render(_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { color: "red", children: ["Unknown command: ", commandName] }), _jsxs(Text, { children: ["Run ", _jsx(Text, { bold: true, children: "svc --help" }), " to see available commands"] })] }));
         process.exit(1);
     }
     // Offer to migrate a legacy plaintext password into the OS keychain.
-    // Interactive `svc` handles this in SetupFlow; this covers direct commands
-    // (svc deploy/dev/sign/…). Skip on non-TTY stdin (e.g. CI) where prompting
-    // would fail — the plaintext password is still used for this run.
+    // Skip on non-TTY stdin (e.g. CI) where prompting would fail — the
+    // plaintext password is still used for this run.
     if (project.hasLegacyPassword && process.stdin.isTTY) {
-        console.log('\n\x1b[33m⚠ Plaintext password found in .dev_properties.json\x1b[0m');
+        say('\n\x1b[33m⚠ Plaintext password found in .dev_properties.json\x1b[0m');
         const move = await promptYesNo('Move it to the OS keychain and remove it from the file? (y/N): ');
         if (move) {
             if (migrateLegacyPassword(project)) {
-                console.log('\x1b[32m✓ Password moved to keychain.\x1b[0m\n');
+                say('\x1b[32m✓ Password moved to keychain.\x1b[0m\n');
             }
             else {
-                console.log('\x1b[31mCould not access keychain; leaving the file unchanged.\x1b[0m\n');
+                say('\x1b[31mCould not move the password; the file still holds it.\x1b[0m\n');
             }
         }
     }
-    // Execute the command
+    debug('command', commandName);
     await command.execute({
         project,
         flags: cli.flags,
         args,
     });
+    shutdown();
 }
 main().catch(error => {
+    debug('crash', errorText(error));
     console.error('Fatal error:', error);
     process.exit(1);
 });

package/dist/commands/TaskScreen.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from 'react';
+import { styleText } from 'node:util';
+import { Box, useStdout } from 'ink';
+import { StatusIndicator } from '../components/StatusIndicator.js';
+import { useTasks } from '../utils/tasks.js';
+import { useFinish } from './use-finish.js';
+const LEVEL_STYLE = { info: 'reset', ok: 'green', warn: 'yellow', error: 'red' };
+/**
+ * A one-shot command: the task's log printed above the status as it comes (a
+ * terminal keeps it in scrollback, CI keeps all of it), then exit with its result.
+ */
+export function TaskScreen({ task, stay = false, children }) {
+    const { write } = useStdout();
+    const live = useTasks().find(t => t.id === task.id) ?? task;
+    const result = live.status === 'running'
+        ? undefined
+        : live.status === 'success'
+            ? 'success'
+            : 'error';
+    // ponytail: counts lines, so past the task's 2000-line cap (where old lines
+    // are dropped) some would be skipped. No one-shot command logs that much.
+    const printed = useRef(0);
+    useEffect(() => {
+        for (const line of live.lines.slice(printed.current)) {
+            write(`${styleText('dim', line.tag.padEnd(3))} ${styleText(LEVEL_STYLE[line.level], line.text)}\n`);
+        }
+        printed.current = live.lines.length;
+    });
+    useFinish(result, stay && result === 'error');
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [_jsx(StatusIndicator, { status: result ?? 'running', label: live.phase, message: `${live.label} ${live.appName}` }), children] }));
+}