@omega.js/desktop 0.1.0

package/dist/commands/cdp/quit.js

@@ -0,0 +1,84 @@
+// `npx omega cdp quit` — quit the running dev app and WAIT for its full process
+// tree to drain (Electron mains + the npm-start chain), so it's safe to run
+// `npx omega test` the moment this returns. Port-down alone is NOT that signal —
+// the chain takes a few more seconds to flush, and a test run started inside
+// that window gets contaminated (slow polls, flaky boot suites).
+//
+// macOS only (osascript).
+
+const { execFileSync } = require('child_process');
+const client = require('./client');
+
+const Manager = new (require('../../build.js'))();
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function portUp() {
+  const response = await fetch(`http://127.0.0.1:${client.port()}/json/version`).catch(() => null);
+  return Boolean(response && response.ok);
+}
+
+// Electron mains (dev AND stray test instances) + the npm-start chain
+// (mgr start / gulp) belonging to THIS project.
+function devProcsAlive() {
+  const escaped = process.cwd().replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  try {
+    const out = execFileSync('pgrep', ['-f', `${escaped}/node_modules/(electron/dist|\\.bin/(mgr start|gulp))`]);
+    return out.toString().trim().split('\n').filter(Boolean).length;
+  } catch (error) {
+    return 0; // pgrep exits 1 when nothing matches
+  }
+}
+
+// True when an app was running and has been quit; false when nothing was up.
+async function quitAndDrain(names) {
+  if (process.platform !== 'darwin') {
+    throw new Error('mgr cdp quit/relaunch is macOS-only (osascript)');
+  }
+
+  if (!await portUp()) {
+    return false;
+  }
+
+  // Real app quit (before-quit handlers run).
+  let lastError = null;
+  for (const name of names) {
+    try {
+      execFileSync('osascript', ['-e', `tell application "${name}" to quit`]);
+      lastError = null;
+      break;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  if (lastError) {
+    throw new Error(`could not quit the app (tried: ${names.join(', ')}): ${lastError.message}`);
+  }
+
+  for (let i = 0; i < 30; i++) {
+    if (!await portUp()) {
+      break;
+    }
+    await sleep(500);
+    if (i === 29) {
+      throw new Error('app did not release the CDP port after quit');
+    }
+  }
+
+  // Port-down ≠ process-tree dead — drain it before returning.
+  for (let i = 0; i < 30; i++) {
+    if (!devProcsAlive()) {
+      return true;
+    }
+    await sleep(500);
+  }
+  console.warn('warning: app processes still draining — wait a moment before running tests');
+  return true;
+}
+
+module.exports = async function (options) {
+  const wasRunning = await quitAndDrain(client.appNames(Manager.getConfig()));
+  console.log(wasRunning ? 'quit running app' : 'app was not running');
+};
+
+module.exports.quitAndDrain = quitAndDrain;

package/dist/commands/cdp/relaunch.js

@@ -0,0 +1,62 @@
+// `npx omega cdp relaunch` — the dev iterate loop in one command. @omega.js/desktop's
+// `npm start` has NO watch (build once, then run), so every src/ edit needs
+// quit → rebuild → boot.
+//
+// Boots with CDP on OMEGA_CDP_PORT (default 9222) so the other cdp subcommands
+// can attach. "Booted" = a page target matching the ready signal exists —
+// default: the main window's document (`/views/main/`); consumers whose boot
+// completes later than first paint override via config `cdp.readySignal`
+// (a URL substring, e.g. an overlay view created last in the boot sequence).
+//
+// The spawned `npm start` is detached and keeps running after this exits;
+// its output goes to logs/dev.log as usual.
+//
+// macOS only (the quit step uses osascript).
+
+const { spawn } = require('child_process');
+const client = require('./client');
+const { quitAndDrain } = require('./quit');
+
+const Manager = new (require('../../build.js'))();
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function portUp() {
+  const response = await fetch(`http://127.0.0.1:${client.port()}/json/version`).catch(() => null);
+  return Boolean(response && response.ok);
+}
+
+async function waitForBoot(matcher) {
+  // Build + boot: electron's own startup takes the bulk of it. Generous ceiling.
+  for (let i = 0; i < 120; i++) {
+    await sleep(2000);
+    if (!await portUp()) {
+      continue;
+    }
+    const pages = await client.targets().catch(() => []);
+    if (client.pickTarget(pages, matcher)) {
+      return;
+    }
+  }
+  throw new Error('boot timeout — check logs/dev.log');
+}
+
+module.exports = async function (options) {
+  const config = Manager.getConfig();
+
+  const wasRunning = await quitAndDrain(client.appNames(config));
+  console.log(wasRunning ? 'quit running app' : 'app was not running');
+
+  const child = spawn('npm', ['start'], {
+    cwd: process.cwd(),
+    env: { ...process.env, OMEGA_CDP_PORT: String(client.port()) },
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+
+  const matcher = client.readyMatcher(config);
+  console.log('building + booting (logs/dev.log)…');
+  await waitForBoot(matcher);
+  console.log(`booted — CDP on ${client.port()}, ready ("${matcher}" target up)`);
+};

package/dist/commands/cdp/shot.js

@@ -0,0 +1,20 @@
+// `npx omega cdp shot <target-match> <out.png>` — per-renderer screenshot: what
+// ONE webContents painted (its own surface).
+//
+// This is NOT the composited window (BrowserWindow document + WebContentsViews
+// stack in the window server) — use `mgr cdp capture` to see what the user
+// actually sees. Per-renderer shots are the discriminator when compositing
+// looks wrong: if this image is correct but capture isn't, the bug is between
+// the renderer and the window server, not in your CSS.
+
+const client = require('./client');
+
+module.exports = async function (options) {
+  const [, , matcher, outPath] = options._;
+  if (!matcher || !outPath) {
+    throw new Error('Usage: npx omega cdp shot <target-match> <out.png>');
+  }
+
+  await client.screenshot(String(matcher), String(outPath));
+  console.log(`saved ${outPath}`);
+};

package/dist/commands/cdp/status.js

@@ -0,0 +1,38 @@
+// `npx omega cdp status` — is the dev app up, and what's in it? One-stop
+// orientation: every CDP page target (the main window's document is marked),
+// the window geometry, and the live theme.
+
+const client = require('./client');
+
+module.exports = async function (options) {
+  let pages;
+  try {
+    pages = await client.targets();
+  } catch (error) {
+    console.log(`App: NOT RUNNING (${error.message})`);
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log(`App: running (CDP port ${client.port()})`);
+  console.log('\nTargets:');
+  for (const t of pages) {
+    const role = t.url.includes(client.MAIN_VIEW) ? 'main' : '    ';
+    console.log(`  [${role}] ${t.url}`);
+  }
+
+  const main = client.pickTarget(pages, client.MAIN_VIEW);
+  if (!main) {
+    console.log(`\n(no ${client.MAIN_VIEW} target — window info unavailable)`);
+    return;
+  }
+
+  const info = await client.evaluate(client.MAIN_VIEW, `(async () => ({
+    window: { x: window.screenX, y: window.screenY, width: window.outerWidth, height: window.outerHeight },
+    bsTheme: document.documentElement.getAttribute('data-bs-theme'),
+    theme: window.desktop?.theme ? await window.desktop.theme.get() : null,
+  }))()`);
+
+  console.log(`\nWindow: ${info.window.width}x${info.window.height} at (${info.window.x}, ${info.window.y})`);
+  console.log(`Theme: ${info.theme ? `source=${info.theme.source} resolved=${info.theme.resolved}` : '(em.theme unavailable)'}${info.bsTheme ? ` data-bs-theme=${info.bsTheme}` : ''}`);
+};

package/dist/commands/cdp/theme.js

@@ -0,0 +1,21 @@
+// `npx omega cdp theme <dark|light|system>` — flip the app's theme live
+// (manager.theme via the main window's renderer).
+//
+// Flips every renderer (BrowserWindows AND WebContentsViews) with no restart —
+// nativeTheme.themeSource → prefers-color-scheme → the preload applier
+// rewrites <html data-bs-theme>. The choice PERSISTS in storage (wins over
+// config.theme.appearance on later boots) — flip back when you're done.
+
+const client = require('./client');
+
+const SOURCES = ['dark', 'light', 'system'];
+
+module.exports = async function (options) {
+  const source = options._[2];
+  if (!SOURCES.includes(source)) {
+    throw new Error(`Usage: npx omega cdp theme <${SOURCES.join('|')}>`);
+  }
+
+  const state = await client.evaluate(client.MAIN_VIEW, `window.desktop.theme.set('${source}')`);
+  console.log(`theme: source=${state.source} resolved=${state.resolved}`);
+};

package/dist/commands/cdp.js

@@ -0,0 +1,53 @@
+// `npx omega cdp <subcommand>` — drive the RUNNING dev app over the Chrome
+// DevTools Protocol: orient (status), act (eval, theme), see (shot, capture),
+// and run the no-watch iterate loop (relaunch / quit).
+//
+//   npx omega cdp status                          # running? targets, window rect, theme
+//   npx omega cdp eval <match> '<expr>'           # evaluate JS in any webContents
+//   npx omega cdp shot <match> <out.png>          # ONE renderer's own pixels
+//   npx omega cdp capture <out.png>               # the COMPOSITED window (macOS)
+//   npx omega cdp theme <dark|light|system>       # flip the live theme
+//   npx omega cdp relaunch                        # quit → npm start → wait for boot
+//   npx omega cdp quit                            # quit + wait for the process tree to drain
+//
+// All subcommands read OMEGA_CDP_PORT (default 9222) — the same env var `npm
+// start` uses to open the endpoint — or take `--port <n>` (which wins).
+// `--port` exists for npm scripts: prefixing `npx cross-env OMEGA_CDP_PORT=…`
+// MANGLES quoted eval expressions (cross-env strips inner quotes), so a
+// pinned-port script must pass the port as a flag instead. Targets are
+// matched by URL substring (the main window is always `/views/main/`).
+// Full reference: docs/cdp-debugging.md.
+
+const path = require('path');
+
+const SUBCOMMANDS = ['status', 'eval', 'shot', 'capture', 'theme', 'relaunch', 'quit'];
+
+const USAGE = [
+  'Usage: npx omega cdp <subcommand> [--port <n>]   (port default: OMEGA_CDP_PORT or 9222)',
+  '  status                       app up? targets, window rect, theme',
+  "  eval <match> '<expr>'        evaluate JS in the matched webContents",
+  '  shot <match> <out.png>       per-renderer screenshot',
+  '  capture <out.png>            composited window capture (macOS)',
+  '  theme <dark|light|system>    flip the live theme',
+  '  relaunch                     quit → npm start → wait for boot',
+  '  quit                         quit the app, wait for processes to drain',
+].join('\n');
+
+module.exports = async function (options) {
+  options = options || {};
+  options._ = options._ || [];
+
+  const sub = options._[1];
+  if (!sub || !SUBCOMMANDS.includes(sub)) {
+    console.error(USAGE);
+    throw new Error(sub ? `Unknown cdp subcommand "${sub}"` : 'Missing cdp subcommand');
+  }
+
+  // --port overrides OMEGA_CDP_PORT for this invocation (client.js reads the env).
+  if (options.port) {
+    process.env.OMEGA_CDP_PORT = String(options.port);
+  }
+
+  const handler = require(path.join(__dirname, 'cdp', `${sub}.js`));
+  await handler(options);
+};

package/dist/commands/clean.js

@@ -0,0 +1,34 @@
+// Libraries
+const Manager = new (require('../build.js'));
+const logger = Manager.logger('clean');
+const { cleanDirs } = require('../vendor/devkit/clean-dirs.js');
+const { ensureTarget } = require('./lib/ensure-target.js');
+
+// Dirs to clean
+const dirs = [
+  '.temp',
+  '.cache',
+  'dist',
+  'release',
+];
+
+module.exports = async function (options) {
+  // The local scaffold (#675): the consumer `start` script is
+  // `omega clean && npm run gulp --`, and gulp itself is one of the peer
+  // deps the ensure installs — clean is the only verb that runs before it.
+  await ensureTarget({ log: (line) => logger.log(line), warn: (line) => logger.warn(line) });
+
+  // Quick mode used to keep `dist/` so "the next gulp run is incremental" —
+  // a claim webpack never made good on (it rebuilt every bundle anyway) and
+  // esbuild retires outright (the numbers are the CHANGELOG's
+  // [#737](https://github.com/Omega-JS-Stack/omega/issues/737) entry). Every run
+  // cleans, so `--quick` now means exactly one thing: the trimmed
+  // electron-builder phase.
+  logger.log('Cleaning .temp, .cache, dist, release...');
+
+  try {
+    cleanDirs(dirs);
+  } catch (e) {
+    logger.error(`Error clearing directories: ${e}`);
+  }
+};

package/dist/commands/deploy.js

@@ -0,0 +1,75 @@
+/**
+ * `omega deploy` — the uniform explicit publish verb (D13). Desktop's real
+ * flow lives in `omega release` (workflow_dispatch + live CI log streaming +
+ * GitHub-release artifacts); this verb exists so every target deploys the
+ * same way. --dry-run prints the exact dispatch release would send, without
+ * sending it; anything else delegates to release.
+ *
+ * Every run starts with the local scaffold the retired `omega setup` used to
+ * own (ensureTarget, #675), delivers the Apple signing artifacts into the
+ * target's certs dir (#678), and then runs setup's NETWORK half as a precheck:
+ * framework freshness, cert validation, repo provisioning, secret publication.
+ * `--no-secrets` skips that precheck.
+ */
+const { execSync } = require('node:child_process');
+const Manager = new (require('../build.js'));
+const logger = Manager.logger('deploy');
+const { deployViaDispatch, findLocalSpecs } = require('../vendor/devkit/deploy.js');
+const { ensureTarget } = require('./lib/ensure-target.js');
+const { deployPrecheck } = require('./lib/deploy-precheck.js');
+const { deliverTargetCerts } = require('../utils/deliver-certs.js');
+const { dispatchTarget } = require('./release.js');
+
+module.exports = async function (options) {
+  options = options || {};
+  const dryRun = options.dryRun || options['dry-run'];
+  const projectDir = process.cwd();
+
+  // The local half of the retired `omega setup` (#675), then the signing
+  // artifacts this target needs before anything signs (#678). Both are
+  // idempotent and quiet on a converged target.
+  await ensureTarget({ projectDir, log: (line) => logger.log(line), warn: (line) => logger.warn(line) });
+  deliverTargetCerts({ projectDir, logger });
+
+  // The NETWORK half, as a precheck: a deploy is the verb that needs the
+  // remote side right. A dry run sends nothing, so it prechecks nothing.
+  if (!dryRun) {
+    await deployPrecheck({ projectDir, options, logger });
+  }
+
+  // Linked local packages (tree-wide file: specs — cp194) → the LOCAL
+  // release flow automatically: build + sign + publish from this machine
+  // with the linked frameworks bundled in. Mirrored rule (Ian 2026-07-20);
+  // CI dispatch is only for registry-clean trees.
+  if (findLocalSpecs({ dir: process.cwd() }).length > 0) {
+    logger.log('Linked local packages detected — running the LOCAL release flow (build + sign + publish from this machine). CI dispatch resumes after `omega i live`.');
+    if (dryRun) {
+      logger.log('DRY RUN — would run: npm run release:local');
+      return;
+    }
+    execSync('npm run release:local', { stdio: 'inherit' });
+    require('../vendor/devkit/deploy-record.js').recordDeploy({ dir: process.cwd(), target: 'desktop', detail: { method: 'local' } });
+    return logger.log('Deployed from the LOCAL release flow (linked frameworks included).');
+  }
+
+  if (dryRun) {
+    const platforms = options.platforms || options.platform || 'all';
+    // The SAME address `omega release` dispatches on (config, and the composed
+    // workflow name inside a brand), so the printed plan is the real one.
+    const target = dispatchTarget({ projectRoot: projectDir, config: Manager.getConfig() });
+    const { plan } = await deployViaDispatch({
+      workflow: target.workflow,
+      owner: target.owner,
+      repo: target.repo,
+      inputs: { platforms: String(platforms) },
+      dryRun: true,
+    });
+    logger.log('DRY RUN — would send:');
+    logger.log(`  ${plan.method} ${plan.url}`);
+    logger.log(`  body: ${JSON.stringify(plan.body)}`);
+    logger.log(`  then watch: ${plan.runsUrl}`);
+    return;
+  }
+
+  return require('./release.js')(options);
+};

package/dist/commands/finalize-release.js

@@ -0,0 +1,238 @@
+// finalize-release — wraps up a release after the matrix builds finish.
+//
+// Two modes (one command, --flag selects):
+//   --signed-dir <path>   Upload signed Windows artifacts to the releases-repo release
+//                         (created earlier by mac/linux's electron-builder --publish).
+//                         Used by the windows-sign CI job.
+//   --publish             Flip that release from draft → published so electron-updater
+//                         can read its feed. Used by the finalize CI job.
+//
+// The repo is the brand's ONE public releases repo, addressed by @omega.js/config's
+// `releasesRepo` from config/omega.json5 alone (#799): the same address the build
+// baked into the app's update feed, never the git remote of whatever repo the
+// target sits in.
+//
+// Both modes find the release by LISTING the repo's releases, drafts included
+// (#810): `repos.getReleaseByTag` returns published releases only, because a draft
+// carries no tag ref, so it 404'd on the very draft electron-builder had just
+// created and every run piled up another draft for the same version.
+//
+// Idempotent: each mode is safe to re-run. An upload whose asset name is already
+// on the release replaces it (delete, then upload), publish uses GH's
+// "set draft=false" which is a no-op if already published.
+
+const path    = require('path');
+const fs      = require('fs');
+const jetpack = require('fs-jetpack');
+
+const { getOctokit } = require('../utils/github.js');
+const { releasesRepo } = require('../vendor/config/index.js');
+const Manager = new (require('../build.js'));
+
+const logger = Manager.logger('finalize-release');
+
+module.exports = async function finalizeRelease(options = {}) {
+  const argv = options._ || [];
+  // Parse flags from yargs-style options (yargs camelCases --signed-dir → signedDir).
+  const signedDir = options.signedDir || options['signed-dir'];
+  const doPublish = options.publish === true;
+
+  if (!signedDir && !doPublish) {
+    throw new Error('finalize-release: pass --signed-dir <path> or --publish');
+  }
+
+  const projectRoot = process.cwd();
+  const config      = Manager.getConfig() || {};
+  const pkgVersion  = (Manager.getPackage('project') || {}).version;
+
+  if (!pkgVersion) {
+    throw new Error('finalize-release: package.json version not found');
+  }
+
+  if (!process.env.GH_TOKEN) {
+    throw new Error('finalize-release: GH_TOKEN not set in env');
+  }
+
+  const octokit = options.octokit || getOctokit();
+  if (!octokit) {
+    throw new Error('finalize-release: failed to create octokit (missing GH_TOKEN?)');
+  }
+
+  // The releases repo (the auto-updater feed source), from config alone.
+  const { owner, name, repo } = releasesRepo(config);
+  if (!repo) {
+    throw new Error('finalize-release: could not address the releases repo. Set repo.providers.github.org (or targets.desktop.releases.owner) and brand.id in config/omega.json5.');
+  }
+
+  const releaseTag = `v${pkgVersion}`;
+
+  if (signedDir) {
+    await uploadSignedWindows({
+      octokit, owner, repo: name, tag: releaseTag,
+      signedDir: path.resolve(projectRoot, signedDir),
+    });
+  }
+
+  if (doPublish) {
+    await publishReleasesRepoRelease({
+      octokit, owner, repo: name, tag: releaseTag,
+    });
+  }
+};
+
+/**
+ * Find the repo's release for a tag, DRAFTS INCLUDED (#810).
+ *
+ * The newest draft wins: that is the one the current run's electron-builder
+ * publish step created, and an older duplicate draft for the same version (what
+ * the tag lookup's blindness left behind) never steals the assets. A published
+ * release for the tag answers when no draft does.
+ *
+ * @param {object} args - Lookup args.
+ * @param {object} args.octokit - Authenticated octokit client.
+ * @param {string} args.owner - Releases repo owner.
+ * @param {string} args.repo - Releases repo name.
+ * @param {string} args.tag - Release tag, e.g. `v1.2.3`.
+ * @returns {Promise<object|null>} The release, or null when the tag has none.
+ */
+async function findRelease({ octokit, owner, repo, tag }) {
+  const releases = await octokit.paginate(octokit.rest.repos.listReleases, {
+    owner, repo, per_page: 100,
+  });
+
+  const matches = releases.filter((release) => release.tag_name === tag);
+  const drafts  = matches
+    .filter((release) => release.draft)
+    .sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
+
+  return drafts[0] || matches.find((release) => !release.draft) || null;
+}
+
+async function uploadSignedWindows({ octokit, owner, repo, tag, signedDir }) {
+  if (!jetpack.exists(signedDir)) {
+    logger.warn(`No signed dir at ${signedDir} — nothing to upload.`);
+    return;
+  }
+
+  const files = (jetpack.list(signedDir) || []).filter((f) => {
+    if (!f.includes('.')) return false;
+    if (f.endsWith('.blockmap')) return false;
+    if (f.endsWith('.yml')) return false;
+    return true;
+  });
+
+  if (files.length === 0) {
+    logger.warn(`No signed files in ${signedDir}.`);
+    return;
+  }
+
+  // Find the release for the tag, drafts included. Normally mac/linux's
+  // electron-builder publish step has already created it (as a draft). For
+  // partial-platform runs (`--platforms windows` on a brand-new version) it
+  // doesn't exist yet, and in that case we create it ourselves as a draft so we
+  // have a place to attach signed assets. The `finalize` job is the one gated on
+  // all-platforms before flipping draft → published, so a draft created here just
+  // sits until a full run completes.
+  let release = await findRelease({ octokit, owner, repo, tag });
+  if (!release) {
+    logger.log(`No release at ${owner}/${repo}@${tag} yet: creating draft so we have somewhere to upload signed assets...`);
+    const { data } = await octokit.rest.repos.createRelease({
+      owner, repo,
+      tag_name: tag,
+      name: tag,
+      body: `Draft release auto-created by @omega.js/desktop for partial-platform run. Will be filled in by subsequent runs and published once all platforms have built.`,
+      draft: true,
+      prerelease: false,
+    });
+    release = data;
+  }
+
+  logger.log(`Uploading ${files.length} signed file(s) to ${owner}/${repo}@${tag} (release id ${release.id})...`);
+
+  // Replace any existing assets with the same name.
+  const { data: existing } = await octokit.rest.repos.listReleaseAssets({
+    owner, repo, release_id: release.id, per_page: 100,
+  });
+  const existingByName = new Map(existing.map((a) => [a.name, a]));
+
+  for (const filename of files) {
+    const src = path.join(signedDir, filename);
+    const data = fs.readFileSync(src);
+
+    const old = existingByName.get(filename);
+    if (old) {
+      logger.log(`  ↻ ${filename} is already on the release (asset ${old.id}): replacing it.`);
+      await octokit.rest.repos.deleteReleaseAsset({ owner, repo, asset_id: old.id });
+    }
+
+    await octokit.rest.repos.uploadReleaseAsset({
+      owner, repo, release_id: release.id,
+      name: filename,
+      data,
+      headers: {
+        'content-type': 'application/octet-stream',
+        'content-length': data.length,
+      },
+    });
+
+    logger.log(`  ✓ ${filename} (${(data.length / 1024 / 1024).toFixed(1)}MB) → ${owner}/${repo}@${tag}`);
+  }
+
+  // Also upload the latest.yml / .blockmap auto-updater metadata if present.
+  const meta = (jetpack.list(signedDir) || []).filter((f) => f.endsWith('.yml') || f.endsWith('.blockmap'));
+  for (const filename of meta) {
+    const src  = path.join(signedDir, filename);
+    const data = fs.readFileSync(src);
+    const old  = existingByName.get(filename);
+    if (old) {
+      logger.log(`  ↻ ${filename} is already on the release (asset ${old.id}): replacing it.`);
+      await octokit.rest.repos.deleteReleaseAsset({ owner, repo, asset_id: old.id });
+    }
+    await octokit.rest.repos.uploadReleaseAsset({
+      owner, repo, release_id: release.id,
+      name: filename,
+      data,
+      headers: { 'content-type': 'application/octet-stream', 'content-length': data.length },
+    });
+    logger.log(`  ✓ ${filename} (auto-updater feed) → ${owner}/${repo}@${tag}`);
+  }
+}
+
+async function publishReleasesRepoRelease({ octokit, owner, repo, tag }) {
+  const release = await findRelease({ octokit, owner, repo, tag });
+
+  if (!release) {
+    throw new Error(`Release ${tag} not found at ${owner}/${repo}. Did the build/publish job succeed?`);
+  }
+
+  if (!release.draft && !release.prerelease) {
+    logger.log(`✓ ${owner}/${repo}@${tag} already published (draft=false, prerelease=false).`);
+  } else {
+    await octokit.rest.repos.updateRelease({
+      owner, repo, release_id: release.id,
+      draft: false,
+      prerelease: false,
+    });
+    logger.log(`✓ Flipped ${owner}/${repo}@${tag} to published (was draft=${release.draft}, prerelease=${release.prerelease}).`);
+  }
+
+  // Sanity check — ensure the auto-updater feeds are present so electron-updater works.
+  const { data: assets } = await octokit.rest.repos.listReleaseAssets({
+    owner, repo, release_id: release.id, per_page: 100,
+  });
+  const names = assets.map((a) => a.name);
+
+  const expected = ['latest.yml', 'latest-mac.yml', 'latest-linux.yml'];
+  const missing  = expected.filter((feed) => !names.includes(feed));
+
+  if (missing.length > 0) {
+    logger.warn(`Auto-updater feeds missing from ${owner}/${repo}@${tag}: ${missing.join(', ')}`);
+    logger.warn('  electron-updater will fail for these platforms until the feed yml is uploaded.');
+  } else {
+    logger.log(`✓ All auto-updater feeds present (${expected.join(', ')}).`);
+  }
+
+  logger.log(`Release URL: https://github.com/${owner}/${repo}/releases/tag/${tag}`);
+}
+
+module.exports.findRelease = findRelease;

package/dist/commands/install.js

@@ -0,0 +1,37 @@
+// Libraries
+const Manager = new (require('../build.js'));
+const logger = Manager.logger('install');
+const local = require('../vendor/devkit/local.js');
+
+const package = Manager.getPackage('main');
+
+module.exports = async function (options) {
+  logger.log(`Installing ${package.name}...`);
+
+  const type = options._[1] || 'prod';
+
+  try {
+    if (['live', 'prod', 'p', 'production'].includes(type)) {
+      // The publish-day inverse of `i local`: flip every file: spec in the
+      // brand tree to the exact <linked version>, then one registry install
+      logger.log('Installing production (restoring registry specs tree-wide)...');
+      const actions = await local.restoreRegistrySpecs({ dir: process.cwd(), logger });
+      const flipped = actions.filter((action) => action.action === 'flip').length;
+      return logger.log(flipped > 0
+        ? `Production installation complete (${flipped} spec(s) restored to registry ranges).`
+        : 'Already on registry specs — nothing to flip.');
+    }
+
+    if (['dev', 'd', 'development', 'local', 'l'].includes(type)) {
+      logger.log('Installing development (local Omega monorepo)...');
+      await local.linkLocalPackages({
+        dir: process.cwd(),
+        monorepoRoot: local.resolveMonorepoRoot(),
+        logger,
+      });
+      return logger.log('Development installation complete.');
+    }
+  } catch (e) {
+    logger.error('Error during install:', e);
+  }
+};