@shardflux/cli 0.18.0-next.4 → 0.18.0

package/dist/t3-linux.js

@@ -3,29 +3,38 @@
  *
  * T3 ships a .deb and an AppImage (electron-builder, 0.0.45 and the nightlies, verified from the release assets):
  * - .deb (package `t3code`): the app in `/opt/T3 Code (Alpha)/` (`/opt/T3 Code (Nightly)/` for nightlies) with the
- *   executable `t3code`, `resources/app.asar` and `resources/package-type` ("deb"); the entry
- *   `/usr/share/applications/t3code.desktop` (`Name=T3 Code (Alpha)`, `Exec="/opt/T3 Code (Alpha)/t3code" %U`,
- *   `StartupWMClass=t3code`, `MimeType=x-scheme-handler/t3code;…`); `/usr/bin/t3code` is an update-alternatives link
- *   made by its postinst. dpkg records nightlies as `0.0.46~nightly.<date>.<run>`.
- * - AppImage: `T3-Code-<version>-<x86_64|arm64>.AppImage`, a squashfs image that is never mounted here; AppImageLauncher
- *   and Gear Lever integrate it with a copy of the same entry (`X-AppImage-Version`, `Exec=<the AppImage> %U`).
+ *   executable `t3code`, `resources/app.asar` (package.json `name: "t3code"`) and `resources/package-type` ("deb");
+ *   the entry `/usr/share/applications/t3code.desktop` (`Name=T3 Code (Alpha)`, `Exec="/opt/T3 Code (Alpha)/t3code"
+ *   %U`, `StartupWMClass=t3code`, `MimeType=x-scheme-handler/t3code;…`); `/usr/bin/t3code` is an update-alternatives
+ *   link made by its postinst. dpkg records nightlies as `0.0.46~nightly.<date>.<run>`.
+ * - AppImage: `T3-Code-<version>-<x86_64|arm64>.AppImage`, a type 2 AppImage (ELF, `AI\x02` at byte 8) that is never
+ *   mounted here; AppImageLauncher and Gear Lever integrate it with a copy of the same entry (`Exec=<the AppImage> %U`).
+ * T3 publishes no flatpak or snap: the flatpak handling below follows flatpak's export layout with T3's app id
+ * (`com.t3tools.t3code`, its AppStream id), an unverified layout; a snap entry is accepted only when it runs an unpacked
+ * T3 directly.
  *
- * Entries are found in the XDG application folders (also snapd's and flatpak's exports) and keyed on what the entry
- * says (its Name, and StartupWMClass, the t3code URL scheme or a T3 flatpak id), never on its file name; only files
- * whose name could be one are read, so a computer without T3 costs a few directory listings and no subprocess.
+ * Entries are found in the XDG application folders (and snapd's and flatpak's exports) and keyed on what the entry says
+ * (its Name, and StartupWMClass, the t3code URL scheme or the flatpak id), never on its file name; only files whose name
+ * could be one are read. An entry is accepted only when it runs T3's own program with options: no shell, env prefix or
+ * other program, and an unpacked app's app.asar must be T3 Code's. Detection never reads the program of an unpacked app,
+ * and a computer without T3 costs a few directory listings and no subprocess.
  */
 import { spawn, spawnSync } from 'node:child_process';
 import { accessSync, constants, openSync, readFileSync, readSync, closeSync, readdirSync, realpathSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, delimiter, dirname, isAbsolute, join, relative } from 'node:path';
-import { T3_SERVER_ENTRY, asarVersion, t3ArchiveSupportsAcp } from "./t3-asar.js";
+import { T3_SERVER_ENTRY, asarPackage, t3ArchiveSupportsAcp } from "./t3-asar.js";
+import { t3WritesLauncher } from "./t3-version.js";
 const RELEASE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
 const MAYBE_ENTRY = /t3|^appimagekit_|^gearlever_/i;
 const APPIMAGE = /^t3[-_ ]?code.*\.appimage$/i;
 /** `T3-Code-<version>-<arch>.AppImage`, also as AppImageLauncher renames it (`…-x86_64_<hash>.AppImage`). */
 const APPIMAGE_VERSION = /^T3[-_ ]?Code-(\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?)-(?:x86_64|x64|amd64|arm64|aarch64|armv7l)(?![0-9A-Za-z])/i;
+/** T3's app id (its AppStream id); a T3 flatpak with it is an assumption, not a published package. */
 const FLATPAK_ID = 'com.t3tools.t3code';
-/** The launcher T3 (nightlies since October 2026) writes to `<T3 home>/bin/t3` for its bundled CLI; for an AppImage it mounts the image itself. */
+/** Programs that would run something other than T3 itself. */
+const WRAPPERS = /^(?:env|sh|bash|dash|zsh|ksh|fish|busybox|sudo|pkexec|nohup)$/;
+/** The launcher T3 (from v0.0.46-preview.20261008.2800) writes to `<T3 home>/bin/t3` for its bundled CLI; for an AppImage it mounts the image itself. */
 export const T3_LAUNCHER_MARKER = "Written by T3 Code: runs the desktop app's bundled t3 CLI.";
 /**
  * The folders scanned on Linux, in XDG precedence: the data home's and each data dir's `applications`, snapd's and
@@ -106,6 +115,12 @@ const executable = (path) => { try {
 catch {
     return false;
 } };
+const isFile = (path) => { try {
+    return statSync(path).isFile();
+}
+catch {
+    return false;
+} };
 const real = (path) => { try {
     return realpathSync(path);
 }
@@ -114,10 +129,8 @@ catch {
 } };
 const onPath = (name, env) => isAbsolute(name) ? (executable(name) ? name : undefined) : (env.PATH ?? '').split(delimiter).filter(Boolean).map(dir => join(dir, name)).find(executable);
 const release = (value) => value && RELEASE.test(value) ? value : null;
-/** A type 2 AppImage: an ELF file with `AI\x02` at byte 8. */
+/** A type 2 AppImage: an ELF file with `AI\x02` at byte 8 (as T3-Code-0.0.45-x86_64.AppImage and the nightlies start). */
 function isAppImage(path) {
-    if (/\.appimage$/i.test(path))
-        return true;
     let fd;
     try {
         fd = openSync(path, 'r');
@@ -139,12 +152,7 @@ function dpkgVersion(env) {
 }
 /** The resources/app.asar of an unpacked Electron app, one or two folders below `root` (a flatpak's files). */
 function findAsar(root) {
-    const at = (dir) => { const asar = join(dir, 'resources', 'app.asar'); try {
-        return statSync(asar).isFile() ? asar : undefined;
-    }
-    catch {
-        return undefined;
-    } };
+    const at = (dir) => { const asar = join(dir, 'resources', 'app.asar'); return isFile(asar) ? asar : undefined; };
     const children = (dir) => { try {
         return readdirSync(dir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => join(dir, d.name));
     }
@@ -153,59 +161,53 @@ function findAsar(root) {
     } };
     return at(root) ?? children(root).map(at).find(Boolean) ?? children(root).flatMap(children).slice(0, 64).map(at).find(Boolean);
 }
-/** The install a T3 entry describes, from its program: an AppImage, a flatpak, a snap, or an unpacked app folder. */
+/** The flatpak an exported entry runs (unverified layout: `flatpak run [options] <id>`, files under the installation). */
+function fromFlatpak(e, exec, id, dir) {
+    const appId = e['X-Flatpak'];
+    if (basename(exec[0]) !== 'flatpak' || !exec.slice(1).every(a => a.startsWith('-') || a === 'run' || a === appId))
+        return undefined;
+    const root = dir.endsWith(join('exports', 'share', 'applications')) ? dirname(dirname(dirname(dir))) : '/var/lib/flatpak';
+    const files = join(root, 'app', appId, 'current', 'active', 'files');
+    const asar = findAsar(files);
+    const pkg = asar ? asarPackage(asar) : null;
+    if (!asar || !pkg?.t3)
+        return undefined;
+    const command = exec.find(a => a.startsWith('--command='))?.slice('--command='.length);
+    const exe = join(dirname(dirname(asar)), basename(command || 't3code'));
+    return { path: exe, version: pkg.version, linux: { format: 'flatpak', desktop_id: id, exec, asar: executable(exe) ? asar : null, flatpak: { id: appId, files } } };
+}
+/**
+ * The install a T3 entry describes: an unpacked app (its program sits next to `resources/app.asar`, which must be T3
+ * Code's; the program itself is never read) or an AppImage (checked by its magic bytes). Refused: a shell, env prefix
+ * or other wrapper, an argument that is not an option, and a program that resolves anywhere else.
+ */
 function fromEntry(e, id, dir, env) {
     const exec = desktopExec(e.Exec ?? '');
     if (!exec?.length)
         return undefined;
-    let i = 0;
-    if (basename(exec[0]) === 'env') {
-        i = 1;
-        while (i < exec.length && /^[A-Za-z_]\w*=/.test(exec[i]))
-            i++;
-    }
-    const program = exec[i];
-    if (!program)
+    if (e['X-Flatpak'])
+        return fromFlatpak(e, exec, id, dir);
+    const [program, ...args] = exec;
+    if (WRAPPERS.test(basename(program)) || args.some(a => !a.startsWith('-')))
         return undefined;
-    const entryVersion = release(e['X-AppImage-Version']);
-    if (e['X-Flatpak']) {
-        const appId = e['X-Flatpak'];
-        const root = dir.endsWith(join('exports', 'share', 'applications')) ? dirname(dirname(dirname(dir))) : '/var/lib/flatpak';
-        const files = join(root, 'app', appId, 'current', 'active', 'files');
-        const asar = findAsar(files) ?? null;
-        const command = exec.find(a => a.startsWith('--command='))?.slice('--command='.length);
-        const exe = asar ? join(dirname(dirname(asar)), basename(command || 't3code')) : files;
-        return { path: exe, version: (asar ? asarVersion(asar) : null) ?? entryVersion, linux: { format: 'flatpak', desktop_id: id, exec, asar: executable(exe) ? asar : null, flatpak: { id: appId, files } } };
-    }
     const resolved = onPath(program, env);
     if (!resolved)
         return undefined;
-    if (e['X-SnapInstanceName'] || resolved.startsWith('/snap/bin/') || dir === '/var/lib/snapd/desktop/applications') {
-        const name = e['X-SnapInstanceName'] || basename(resolved);
-        let version = null;
+    const target = real(resolved), resources = join(dirname(target), 'resources');
+    if (isFile(join(resources, 'app.asar')) || isFile(join(resources, 'package-type'))) {
+        const asar = join(resources, 'app.asar'), pkg = asarPackage(asar);
+        if (!pkg?.t3)
+            return undefined;
+        let deb = false;
         try {
-            version = release(/^version:\s*['"]?([^'"\s]+)/m.exec(readFileSync(join('/snap', name, 'current', 'meta', 'snap.yaml'), 'utf8'))?.[1]);
+            deb = readFileSync(join(resources, 'package-type'), 'utf8').trim() === 'deb';
         }
-        catch { /* no snap metadata */ }
-        return { path: resolved, version, linux: { format: 'snap', desktop_id: id, exec, asar: null } };
+        catch { /* not from the .deb */ }
+        return { path: target, version: pkg.version ?? (deb ? dpkgVersion(env) : null), linux: { format: deb ? 'deb' : 'directory', desktop_id: id, exec, asar } };
     }
-    const target = real(resolved);
-    if (isAppImage(target)) {
-        return { path: target, version: entryVersion ?? release(APPIMAGE_VERSION.exec(basename(target))?.[1]), linux: { format: 'appimage', desktop_id: id, exec, asar: null } };
-    }
-    const asar = join(dirname(target), 'resources', 'app.asar');
-    let found = false;
-    try {
-        found = statSync(asar).isFile();
-    }
-    catch { /* not an unpacked Electron app */ }
-    let deb = false;
-    try {
-        deb = readFileSync(join(dirname(target), 'resources', 'package-type'), 'utf8').trim() === 'deb';
-    }
-    catch { /* not from the .deb */ }
-    const version = (found ? asarVersion(asar) : null) ?? (deb ? dpkgVersion(env) : null) ?? entryVersion;
-    return { path: target, version, linux: { format: deb ? 'deb' : 'directory', desktop_id: id, exec, asar: found ? asar : null } };
+    if (!isAppImage(target))
+        return undefined;
+    return { path: target, version: release(e['X-AppImage-Version']) ?? release(APPIMAGE_VERSION.exec(basename(target))?.[1]), linux: { format: 'appimage', desktop_id: id, exec, asar: null } };
 }
 /** The installed T3 Code apps on Linux, from the desktop entries and AppImages in `dirs` (linuxApplicationDirs). */
 export function linuxT3Apps(dirs, env) {
@@ -244,26 +246,21 @@ export function linuxT3Apps(dirs, env) {
     }
     for (const file of loose) {
         const path = real(file);
-        if (!executable(path) || found.some(f => f.path === path))
+        if (found.some(f => f.path === path) || !executable(path) || !isAppImage(path))
             continue;
         found.push({ path, version: release(APPIMAGE_VERSION.exec(basename(path))?.[1]), linux: { format: 'appimage', desktop_id: null, exec: [path], asar: null } });
     }
     return found;
 }
-/** `0.0.46` and later (nightlies of 0.0.46 included). */
-const atLeast046 = (version) => {
-    const [major = 0, minor = 0, patch = 0] = /^(\d+)\.(\d+)\.(\d+)/.exec(version ?? '')?.slice(1).map(Number) ?? [];
-    return major > 0 || minor > 0 || patch >= 46;
-};
 /**
  * Whether this install runs the Shardflux provider (ACP mode): the server in its app.asar has the ACP Registry driver
- * (deb, unpacked installs, flatpak). An AppImage is never mounted to look: its version decides (0.0.46+ have the
- * driver), and T3's own launcher issues its sessions. A snap starts threads over SSH.
+ * (deb, unpacked installs, flatpak). An AppImage is never mounted to look: its sessions come from T3's own launcher, so
+ * it is ACP from the first build that writes one (t3WritesLauncher); earlier builds start threads over SSH.
  */
 export function linuxSupportsAcp(app) {
     if (app.linux.format === 'appimage')
-        return !!app.version && atLeast046(app.version);
-    return app.linux.format !== 'snap' && !!app.linux.asar && t3ArchiveSupportsAcp(app.linux.asar);
+        return t3WritesLauncher(app.version);
+    return !!app.linux.asar && t3ArchiveSupportsAcp(app.linux.asar);
 }
 /**
  * The bundled T3 server CLI (Electron as Node, ELECTRON_RUN_AS_NODE=1 set by the caller): the app's executable with
@@ -288,6 +285,16 @@ export function linuxServerCli(app, t3Home) {
     }
     return undefined;
 }
+/**
+ * The environment T3 is opened with: the caller's, without what would make its Electron run as plain Node
+ * (ELECTRON_RUN_AS_NODE: `t3code` would exit at once while the open still looked fine) or detach its console.
+ */
+export function t3OpenEnv(env) {
+    const clean = { ...env };
+    delete clean.ELECTRON_RUN_AS_NODE;
+    delete clean.ELECTRON_NO_ATTACH_CONSOLE;
+    return clean;
+}
 /**
  * How T3 is opened (or brought to the front, as a second launch of T3 hands over to the running one): `gtk-launch`
  * with its desktop entry when there is one, else its own program, started detached.
@@ -301,7 +308,8 @@ export function linuxOpenCommands(app, env) {
     ];
 }
 /** Opens T3 Code on Linux. Nothing here ever stops a T3 process: a launcher that hangs is left alone. */
-export async function openLinuxT3(env, app) {
+export async function openLinuxT3(callerEnv, app) {
+    const env = t3OpenEnv(callerEnv);
     let last;
     for (const { command, args, detached } of linuxOpenCommands(app, env)) {
         try {
@@ -327,17 +335,3 @@ export async function openLinuxT3(env, app) {
     }
     throw new Error(`could not open T3 Code (${last instanceof Error ? last.message : String(last)})`);
 }
-/**
- * When T3 last started, as the filesystem records it: the program's access time once it is later than its modification
- * time (dpkg installs both at the build time; relatime updates the access time on the first start, then daily). Null
- * before the first start and on noatime mounts.
- */
-export function linuxLastUsed(path) {
-    try {
-        const s = statSync(path);
-        return s.atimeMs > s.mtimeMs + 1000 ? new Date(s.atimeMs).toISOString() : null;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/t3-mode.d.ts

@@ -47,8 +47,9 @@ export interface T3ThreadResult {
     effort_reason?: EffortReason;
 }
 /**
- * Native lookups that tests replace: Spotlight's last-used dates of app bundles, one `mdls` for all of them (macOS), or
- * when each program last started, from its access time (Linux, t3-linux.ts).
+ * Native lookups that tests replace: Spotlight's last-used dates of app bundles, one `mdls` for all of them (macOS).
+ * Linux has no reliable signal, so every date is null there: dpkg sets the program's access time to the install time,
+ * and any read (a scan, `dpkg --verify`, a backup) moves it.
  */
 export declare const t3Native: {
     lastUsedMany(paths: readonly string[], env: Record<string, string | undefined>, platform?: NodeJS.Platform): Record<string, string | null>;
@@ -56,7 +57,7 @@ export declare const t3Native: {
 /** Spotlight takes about 40 ms per call, so the dates are kept for a few minutes (app-usage.json in the config dir). */
 export declare const LAST_USED_TTL_MS: number;
 export declare function lastUsedDates(ctx: Ctx, paths: readonly string[], now?: number): Record<string, string | null>;
-/** The installed T3 Code, preferring a build with ACP providers when several channels are installed. */
+/** The installed T3 Code: the newest build with ACP providers when several are installed (preferredT3). */
 export declare function t3Install(env: Record<string, string | undefined>, platform?: NodeJS.Platform, dirs?: string[]): T3Install | undefined;
 export { t3HomeDir };
 /** The Shardflux provider instance in T3's server settings (read only; every `shard` run writes it, see t3-provider.ts). */

package/dist/t3-mode.js

@@ -24,9 +24,9 @@ import { basename, join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { CodedError, UsageError, describeError } from "./errors.js";
 import { AgentStateStore } from "./agent-state.js";
-import { applicationDirs, desktopAppPath, t3Apps } from "./agent-targets.js";
-import { configureT3Provider, t3BundleSupportsAcp, t3HomeDir } from "./t3-provider.js";
-import { linuxLastUsed, linuxServerCli, linuxSupportsAcp, openLinuxT3 } from "./t3-linux.js";
+import { applicationDirs, desktopAppPath, preferredT3, t3Apps } from "./agent-targets.js";
+import { configureT3Provider, t3HomeDir } from "./t3-provider.js";
+import { linuxServerCli, openLinuxT3, t3OpenEnv } from "./t3-linux.js";
 import { acpSignedIn } from "./acp-login.js";
 import { AcpModelCache } from "./acp-models.js";
 import { nativeModelOptions } from "./acp-catalog.js";
@@ -49,15 +49,16 @@ const isoDate = (raw) => {
     return parsed && !Number.isNaN(parsed.getTime()) ? parsed.toISOString() : null;
 };
 /**
- * Native lookups that tests replace: Spotlight's last-used dates of app bundles, one `mdls` for all of them (macOS), or
- * when each program last started, from its access time (Linux, t3-linux.ts).
+ * Native lookups that tests replace: Spotlight's last-used dates of app bundles, one `mdls` for all of them (macOS).
+ * Linux has no reliable signal, so every date is null there: dpkg sets the program's access time to the install time,
+ * and any read (a scan, `dpkg --verify`, a backup) moves it.
  */
 export const t3Native = {
     lastUsedMany(paths, env, platform = process.platform) {
         if (!paths.length)
             return {};
         if (platform !== 'darwin')
-            return Object.fromEntries(paths.map(path => [path, linuxLastUsed(path)]));
+            return Object.fromEntries(paths.map(path => [path, null]));
         const r = spawnSync('mdls', ['-name', 'kMDItemLastUsedDate', '-raw', ...paths], { env, encoding: 'utf8', input: '', timeout: 3000 });
         // -raw separates the values with NUL; a bundle Spotlight has no date for prints "(null)".
         const values = r.status === 0 ? r.stdout.split('\0').map(v => v.trim()) : [];
@@ -83,14 +84,13 @@ export function lastUsedDates(ctx, paths, now = Date.now()) {
     catch { /* a cache only */ }
     return dates;
 }
-/** Whether an installed T3 runs the Shardflux provider: its server has the ACP Registry driver (t3-asar.ts, t3-linux.ts). */
-const supportsAcp = (app) => app.linux ? linuxSupportsAcp({ ...app, linux: app.linux }) : t3BundleSupportsAcp(app.path);
-/** The installed T3 Code, preferring a build with ACP providers when several channels are installed. */
+/** The installed T3 Code: the newest build with ACP providers when several are installed (preferredT3). */
 export function t3Install(env, platform = process.platform, dirs = applicationDirs(env, platform)) {
-    const apps = t3Apps(dirs, platform, env);
-    const acp = apps.find(supportsAcp);
-    const app = acp ?? apps[0];
-    return app ? { path: app.path, version: app.version, mode: acp ? 'acp' : 'ssh', ...(app.linux ? { linux: app.linux } : {}) } : undefined;
+    const picked = preferredT3(t3Apps(dirs, platform, env));
+    if (!picked)
+        return undefined;
+    const { app, acp } = picked;
+    return { path: app.path, version: app.version, mode: acp ? 'acp' : 'ssh', ...(app.linux ? { linux: app.linux } : {}) };
 }
 export { t3HomeDir };
 /** The Shardflux provider instance in T3's server settings (read only; every `shard` run writes it, see t3-provider.ts). */
@@ -219,7 +219,8 @@ export async function openT3(env, install) {
         throw t3NotInstalled();
     if (install.linux)
         return openLinuxT3(env, { path: install.path, version: install.version, linux: install.linux });
-    const child = spawn('open', ['-a', install.path], { env, stdio: 'ignore' });
+    // As on Linux: an inherited ELECTRON_RUN_AS_NODE would start T3 as plain Node (t3OpenEnv).
+    const child = spawn('open', ['-a', install.path], { env: t3OpenEnv(env), stdio: 'ignore' });
     await new Promise((resolve, reject) => {
         const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('T3 Code did not open in time')); }, 10_000);
         child.once('error', e => { clearTimeout(timer); reject(e); });

package/dist/t3-version.d.ts

@@ -0,0 +1,8 @@
+/** Orders T3 versions (newest last): by release, a release after its own prereleases, builds of one release by run. */
+export declare function compareT3Versions(a: string | null, b: string | null): number;
+/**
+ * Whether this T3 writes its own CLI launcher (`<T3 home>/bin/t3`, DesktopCliShim, upstream 73e87f683ae1 of
+ * 2026-10-07): 0.0.46 builds from run 2800 on (v0.0.46-preview.20261008.2800 is the first; nightly 2787 predates it),
+ * 0.0.46 itself and later releases.
+ */
+export declare function t3WritesLauncher(version: string | null): boolean;

package/dist/t3-version.js

@@ -0,0 +1,42 @@
+/**
+ * T3 Code release versions: `0.0.45`, and builds of the next release `0.0.46-<nightly|preview>.<YYYYMMDD>.<run>`, where
+ * `<run>` is one CI run counter shared by both channels (nightly 2787 < preview 2800 < nightly 2801).
+ */
+const PARTS = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
+function parse(version) {
+    const m = PARTS.exec(version);
+    if (!m)
+        return undefined;
+    const pre = m[4] ?? null;
+    return { core: [Number(m[1]), Number(m[2]), Number(m[3])], pre, run: pre ? Number(/\.(\d+)$/.exec(pre)?.[1] ?? NaN) : null };
+}
+/** Orders T3 versions (newest last): by release, a release after its own prereleases, builds of one release by run. */
+export function compareT3Versions(a, b) {
+    const x = a ? parse(a) : undefined, y = b ? parse(b) : undefined;
+    if (!x || !y)
+        return x ? 1 : y ? -1 : 0;
+    for (let i = 0; i < 3; i++)
+        if (x.core[i] !== y.core[i])
+            return x.core[i] - y.core[i];
+    if (!x.pre || !y.pre)
+        return x.pre ? -1 : y.pre ? 1 : 0;
+    if (Number.isFinite(x.run) && Number.isFinite(y.run) && x.run !== y.run)
+        return x.run - y.run;
+    return x.pre < y.pre ? -1 : x.pre > y.pre ? 1 : 0;
+}
+/**
+ * Whether this T3 writes its own CLI launcher (`<T3 home>/bin/t3`, DesktopCliShim, upstream 73e87f683ae1 of
+ * 2026-10-07): 0.0.46 builds from run 2800 on (v0.0.46-preview.20261008.2800 is the first; nightly 2787 predates it),
+ * 0.0.46 itself and later releases.
+ */
+export function t3WritesLauncher(version) {
+    const v = version ? parse(version) : undefined;
+    if (!v)
+        return false;
+    const [major, minor, patch] = v.core;
+    if (major > 0 || minor > 0 || patch > 46)
+        return true;
+    if (patch < 46)
+        return false;
+    return !v.pre || (Number.isFinite(v.run) && v.run >= 2800);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shardflux/cli",
-  "version": "0.18.0-next.4",
+  "version": "0.18.0",
   "type": "module",
   "description": "shard: the Shardflux command line. Create an account, sign in, set up keys and billing, then open, run commands in, move files to, suspend, resume and fork serverless agent workspaces.",
   "license": "Apache-2.0",
@@ -43,17 +43,31 @@
     "access": "public"
   },
   "dependencies": {
-    "@shardflux/sdk": "0.24.0-next.4",
     "classic-level": "3.0.0",
     "smol-toml": "1.9.0",
     "snappyjs": "0.7.0",
-    "yaml": "2.9.1"
+    "yaml": "2.9.1",
+    "@shardflux/sdk": "^0.24.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@types/node": "24.13.6",
+    "eslint": "10.11.0",
+    "playwright": "1.62.1",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.70.1"
   },
   "optionalDependencies": {
-    "@shardflux/menubar-darwin": "^0.5.0",
-    "@shardflux/desktop-linux-x64": "0.1.0-next.4",
-    "@shardflux/desktop-linux-arm64": "0.1.0-next.4"
+    "@shardflux/desktop-linux-x64": "0.1.0",
+    "@shardflux/desktop-linux-arm64": "0.1.0",
+    "@shardflux/menubar-darwin": "^0.6.0"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint .",
+    "test": "node --test test/*.test.ts"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts"
-}
+}