tmux-ide 2.8.0 → 2.9.0-beta.14

package/packages/daemon/dist/lib/manifest-pack.d.ts

@@ -1,79 +0,0 @@
-import type { AgentManifest } from "../tui/detect/manifest.ts";
-/** The pack-format version this build understands. */
-export declare const MANIFEST_PACK_SCHEMA = 1;
-/** The release asset name a pack is published under. */
-export declare const MANIFEST_PACK_ASSET = "agent-manifests.json";
-/** Env override for the pack URL (tests/dev; may be `file://` or loopback http). */
-export declare const MANIFEST_PACK_URL_ENV = "TMUX_IDE_MANIFEST_PACK_URL";
-/** A fetched/validated manifest pack. */
-export interface ManifestPack {
-    schema: number;
-    /** Pack version — informational (surfaced in logs), any non-empty string. */
-    pack: string;
-    manifests: AgentManifest[];
-}
-/**
- * PURE — the default pack URL for a version:
- * `https://github.com/<repo>/releases/download/v<version>/agent-manifests.json`
- * (the same asset-URL construction as the TUI binary download).
- */
-export declare function manifestPackUrl(version?: string): string;
-/**
- * PURE — is `url` an acceptable pack source? `https:` always; `file:` and
- * LOOPBACK `http:` (127.0.0.1 / localhost / [::1]) only so tests and local
- * fixtures can drive the flow. Any other scheme/host is rejected.
- */
-export declare function isAllowedPackUrl(url: string): boolean;
-/**
- * PURE — validate an untrusted pack document. Returns the typed pack or a
- * human-readable reason. Every manifest entry must pass the SAME structural
- * validation user override files do ({@link validateManifestShape}) — one bad
- * entry rejects the whole pack (a partial install would be harder to reason
- * about than a loud failure). Never throws.
- */
-export declare function validateManifestPack(value: unknown): {
-    ok: true;
-    pack: ManifestPack;
-} | {
-    ok: false;
-    reason: string;
-};
-/** The installed pack's directory: `<agent-detection>/pack/`. */
-export declare function packDir(): string;
-/** The installed pack's path: `<agent-detection>/pack/manifest-pack.json`. */
-export declare function packPath(): string;
-/**
- * io — fetch and validate a pack. `file://` URLs are read from disk (Node's
- * fetch does not speak file:); everything else goes through fetch with a
- * timeout. THROWS with an actionable message on a disallowed URL, a failed
- * fetch, malformed JSON, or a schema-invalid pack — the caller decides whether
- * that is loud (CLI) or swallowed (the background refresh).
- */
-export declare function fetchManifestPack(url: string, timeoutMs?: number): Promise<ManifestPack>;
-/**
- * io — write a validated pack into place atomically (temp-in-same-dir →
- * rename, so a crash never leaves a half-written pack the loader would then
- * warn about every run). Returns the installed path.
- */
-export declare function installManifestPack(pack: ManifestPack, dest?: string): string;
-/**
- * io — the `tmux-ide update --manifests` flow: resolve the URL (env override →
- * the release-asset default), fetch, validate, install. Throws loudly on any
- * failure (the CLI surfaces it); returns what was installed for reporting.
- */
-export declare function updateManifestPack(opts?: {
-    url?: string;
-    log?: (msg: string) => void;
-}): Promise<{
-    path: string;
-    packVersion: string;
-    count: number;
-}>;
-/**
- * io — the GATED background refresh the daily update check invokes (see
- * `runUpdateCheck` in {@link ./update-check.ts}). Opt-in via
- * `updates.manifests: true` (default false); NEVER throws — a failed refresh
- * just keeps the previous pack, exactly like a failed version check keeps the
- * previous `latest`.
- */
-export declare function maybeRefreshManifestPack(): Promise<void>;

package/packages/daemon/dist/lib/output.d.ts

@@ -1,9 +0,0 @@
-import { IdeError, TmuxError } from "./errors.ts";
-import type { IdeConfig } from "../types.ts";
-export declare function printLayout(config: IdeConfig): void;
-export declare function outputError(message: string, code: string, { exitCode }?: {
-    exitCode?: number;
-}): never;
-export declare function printCommandError(error: IdeError | TmuxError, { json }?: {
-    json?: boolean;
-}): never;

package/packages/daemon/dist/lib/project-init-runner.d.ts

@@ -1,46 +0,0 @@
-/**
- * Run `tmux-ide init [--template <id>]` in a target directory and stream the
- * output line-by-line. Used by `POST /api/projects/init` so the dashboard can
- * scaffold new projects from the UI.
- *
- * The spawn helper is pluggable so tests can drive the runner without
- * actually shelling out.
- */
-import { type ChildProcessWithoutNullStreams } from "node:child_process";
-/**
- * The minimal contract of `child_process.spawn` we depend on. Tests pass in
- * a synthetic implementation that emits lines deterministically.
- */
-export type SpawnFn = (command: string, args: string[], options: {
-    cwd: string;
-}) => ChildProcessWithoutNullStreams;
-export interface InitRunnerOptions {
-    template?: string;
-    cwd: string;
-    onChunk: (chunk: string) => void;
-    /** Override for tests. */
-    spawnFn?: SpawnFn;
-    /** Defaults to 30s. */
-    timeoutMs?: number;
-    /** The binary to run. Defaults to `tmux-ide`; tests pin to a no-op. */
-    command?: string;
-}
-export declare class ProjectInitTimeoutError extends Error {
-    readonly timeoutMs: number;
-    constructor(timeoutMs: number);
-}
-export declare class ProjectInitFailedError extends Error {
-    readonly exitCode: number | null;
-    readonly stderr: string;
-    constructor(exitCode: number | null, stderr: string);
-}
-/**
- * Spawn `tmux-ide init` and resolve when it exits. Streams stdout+stderr
- * through `onChunk` line-by-line so callers can fan them out over WebSocket.
- *
- * Resolves with `{ ok: true }` on exit code 0, rejects with
- * `ProjectInitFailedError` (non-zero) or `ProjectInitTimeoutError` (>30s).
- */
-export declare function runInit(options: InitRunnerOptions): Promise<{
-    ok: true;
-}>;

package/packages/daemon/dist/lib/project-inspect.d.ts

@@ -1,28 +0,0 @@
-/**
- * Project inspect — looks at an arbitrary directory and reports whether it
- * has an `ide.yml`, basic git identity, and the detected stack signals from
- * `src/detect.ts`. Crucially, this is registry-agnostic: it never touches
- * `~/.tmux-ide/projects.json`, so the dashboard can probe directories the
- * user is just considering before deciding to register them.
- *
- * The git + ide.yml bits delegate to `probeProject` so we don't duplicate
- * the timeout-bounded git invocations. The stack detection delegates to
- * `detectStack` from `src/detect.ts` so the wire format stays in sync with
- * `tmux-ide detect`.
- */
-import type { ProjectInspect } from "../schemas/inspect.ts";
-import { type ProbeIo } from "./project-probe.ts";
-export declare class InspectDirNotFoundError extends Error {
-    readonly code = "DIR_NOT_FOUND";
-    constructor(dir: string);
-}
-export interface InspectIo {
-    exists?: (path: string) => boolean;
-    probeIo?: ProbeIo;
-}
-/**
- * Inspect a directory and return identity + detected stack. Throws
- * `InspectDirNotFoundError` if the directory doesn't exist; otherwise
- * never throws (probe + detect both swallow internal failures).
- */
-export declare function inspectProject(dir: string, io?: InspectIo): Promise<ProjectInspect>;

package/packages/daemon/dist/lib/project-onboard.d.ts

@@ -1,58 +0,0 @@
-/**
- * Project onboard — composes a sensible `ide.yml` from a small set of
- * inputs (project name, agent count, optional dev/test commands) and
- * writes it to disk so the project can be registered.
- *
- * `composeIdeYml` is the pure-logic bit (string in → string out) so the
- * shape of the generated config is exhaustively unit-tested without
- * touching the filesystem. The wrapper around `writeConfig` lives in the
- * server route, which calls this function and then `registerProject`.
- */
-import type { IdeConfig } from "../schemas/ide-config.ts";
-export declare class OnboardConflictError extends Error {
-    readonly code = "IDE_YML_EXISTS";
-    constructor(path: string);
-}
-export declare class OnboardInvalidInputError extends Error {
-    readonly code = "INVALID_INPUT";
-    constructor(message: string);
-}
-export interface ComposeIdeYmlInput {
-    /** Final project name written to the `name:` field. */
-    name: string;
-    /** 1, 2, or 3 — how many Claude panes to put in the top row. */
-    agents: number;
-    /**
-     * Optional per-agent pane titles. When provided, length must equal
-     * `agents`; otherwise it's ignored and the canonical defaults are used
-     * (`Lead`/`Teammate N` for team layouts, `Claude N` for solo).
-     */
-    agentNames?: string[];
-    /** Dev server command. `null` / undefined → no dev pane. */
-    devCommand?: string | null;
-    /** Test command. Currently unused in the generated layout but kept for future. */
-    testCommand?: string | null;
-    /** Lint command. Currently unused in the generated layout but kept for future. */
-    lintCommand?: string | null;
-}
-/**
- * Build the `IdeConfig` value the wizard should write. Pure: same input →
- * same output, no io.
- *
- * Layout shape:
- *   - Row 0 (70%): N Claude panes, first focused. When `agents > 1`, the
- *     `team:` block is added so Claude Code launches with team mode.
- *   - Row 1 (30%): Dev pane (if `devCommand` set) + Shell pane.
- */
-export declare function composeIdeYmlConfig(input: ComposeIdeYmlInput): IdeConfig;
-/**
- * Render a composed `IdeConfig` as YAML. Wrapper over `js-yaml` with the
- * same options used elsewhere so the output shape is identical.
- */
-export declare function composeIdeYml(input: ComposeIdeYmlInput): string;
-/**
- * Reject onboarding when `ide.yml` already exists. The caller writes the
- * file separately via `writeConfig`; this helper exists so the route can
- * 409 cleanly without ever overwriting user content.
- */
-export declare function assertNoExistingIdeYml(dir: string, exists?: (path: string) => boolean): void;

package/packages/daemon/dist/lib/project-probe.d.ts

@@ -1,35 +0,0 @@
-/**
- * Project probe — inspects a directory and returns identity facts (name from
- * basename, ide.yml presence, git origin/branch). Pure-ish wrapper over a few
- * filesystem and git child-process calls; the io functions are pluggable for
- * tests so we don't need a full mock filesystem.
- *
- * All git invocations are hard-bounded by a 2s timeout — we never want a
- * single misbehaving repo to hang an HTTP request.
- */
-export interface ProjectProbe {
-    name: string;
-    dir: string;
-    hasIdeYml: boolean;
-    gitOrigin: string | null;
-    gitBranch: string | null;
-}
-/**
- * Pluggable io for tests. The defaults are real fs/child_process calls — pass
- * `io` overrides to drive the probe deterministically in unit tests.
- */
-export interface ProbeIo {
-    exists(path: string): boolean;
-    runGit(args: string[], cwd: string): Promise<string | null>;
-}
-/**
- * Replace dangerous filename characters and collapse whitespace so the
- * default `name` is safe to use as a tmux session name and a registry key.
- */
-export declare function sanitizeName(raw: string): string;
-/**
- * Probe a directory and return its identity. Never throws — returns nulls for
- * any field that can't be determined. The caller decides what's a hard error
- * (e.g. dir doesn't exist).
- */
-export declare function probeProject(dir: string, io?: ProbeIo): Promise<ProjectProbe>;

package/packages/daemon/dist/lib/project-registry.d.ts

@@ -1,76 +0,0 @@
-/**
- * Project registry — persists the list of projects the user has registered
- * with tmux-ide via the dashboard. Stored at `~/.tmux-ide/projects.json`,
- * written atomically via temp+rename (same approach as task-store).
- *
- * The pure decider (`applyAction`) is exported separately from the io-bound
- * accessors so tests can reason about state transitions without hitting the
- * filesystem. The module also exposes a `projectRegistryEmitter` that the
- * `/ws/events` channel listens on to broadcast `projects.changed` frames.
- */
-import { EventEmitter } from "node:events";
-import { type RegisteredProject } from "../schemas/registry.ts";
-import { type ProbeIo, type ProjectProbe } from "./project-probe.ts";
-export declare class ProjectRegistryError extends Error {
-    readonly code: string;
-    constructor(message: string, code: string);
-}
-export declare class ProjectAlreadyRegisteredError extends ProjectRegistryError {
-    readonly suggestion: string;
-    constructor(name: string, suggestion: string);
-}
-export declare class ProjectNotFoundError extends ProjectRegistryError {
-    constructor(name: string);
-}
-export declare class ProjectDirNotFoundError extends ProjectRegistryError {
-    constructor(dir: string);
-}
-export type RegistryAction = {
-    type: "register";
-    project: RegisteredProject;
-} | {
-    type: "unregister";
-    name: string;
-} | {
-    type: "replace";
-    project: RegisteredProject;
-};
-export declare function applyAction(state: readonly RegisteredProject[], action: RegistryAction): RegisteredProject[];
-/**
- * Resolve a unique name for a probed project, appending `-2`, `-3`, … until
- * we don't collide with an existing entry.
- */
-export declare function resolveUniqueName(state: readonly RegisteredProject[], desired: string): string;
-/**
- * Build a `RegisteredProject` value from a probe + chosen name + timestamp.
- * Pure — separated from `registerProject` so tests can verify the shape
- * without io.
- */
-export declare function buildRegisteredProject(probe: ProjectProbe, name: string, registeredAt: string): RegisteredProject;
-export declare const projectRegistryEmitter: EventEmitter<any>;
-export declare function listProjects(): RegisteredProject[];
-export declare function getProject(name: string): RegisteredProject | null;
-export interface RegisterInput {
-    dir: string;
-    name?: string;
-    /** Pluggable io for tests. */
-    io?: ProbeIo;
-    /** Override `Date.now()` for deterministic tests. */
-    now?: () => Date;
-    /** Override existsSync for the dir-validity check (tests). */
-    exists?: (path: string) => boolean;
-}
-export declare function registerProject(input: RegisterInput): Promise<RegisteredProject>;
-export declare function unregisterProject(name: string): void;
-export interface ProbeOptions {
-    io?: ProbeIo;
-}
-/**
- * Re-probe a registered project by name, persist the refreshed snapshot, and
- * broadcast the change. Throws if the project isn't registered.
- */
-export declare function refreshProject(name: string, options?: ProbeOptions): Promise<RegisteredProject>;
-/** Reset the in-memory cache. Tests use this between cases. */
-export declare function _resetCacheForTests(): void;
-/** Force a re-read from disk on next access. */
-export declare function _invalidateCacheForTests(): void;

package/packages/daemon/dist/lib/session-monitor.d.ts

@@ -1,15 +0,0 @@
-interface MonitorPane {
-    id: string;
-    pid: string;
-    cmd?: string;
-    title?: string;
-    role?: string;
-    type?: string;
-    name?: string;
-}
-export declare function computePortPanes(panes: MonitorPane[], { listeners, tree }?: {
-    listeners?: Set<string>;
-    tree?: Map<string, string>;
-}): Set<string>;
-export declare function computeAgentStates(panes: MonitorPane[]): Map<string, "busy" | "idle" | null>;
-export {};

package/packages/daemon/dist/lib/session-options.d.ts

@@ -1,13 +0,0 @@
-/**
- * Composable builders for tmux session configuration.
- * Each returns an array of tmux command arrays.
- */
-import type { ThemeConfig, TmuxCommand } from "../types.ts";
-export declare function buildSessionOptions(session: string, { theme }?: {
-    theme?: ThemeConfig;
-}): TmuxCommand[];
-export declare function themeOptions(session: string, theme: ThemeConfig): TmuxCommand[];
-export declare function borderOptions(session: string, theme: ThemeConfig): TmuxCommand[];
-export declare function behaviorOptions(session: string): TmuxCommand[];
-export declare function statusBarOptions(session: string, theme: ThemeConfig): TmuxCommand[];
-export declare function keyBindings(): TmuxCommand[];

package/packages/daemon/dist/lib/shell.d.ts

@@ -1,5 +0,0 @@
-/**
- * Quote a string for safe embedding in POSIX sh/bash commands as a single word.
- * Wraps in single quotes; embedded `'` becomes `'\''` (end quote, literal quote, resume).
- */
-export declare function shellEscape(s: string): string;

package/packages/daemon/dist/lib/sizes.d.ts

@@ -1,16 +0,0 @@
-/**
- * Compute absolute sizes for items where some have explicit sizes and others don't.
- * Items with `size` (e.g. "70%") keep their value; remaining space is split equally
- * among items without a size.
- */
-export declare function computeSizes(items: {
-    size?: string;
-}[]): number[];
-/**
- * Convert absolute sizes (e.g. [70, 30]) to tmux split percentages for sequential splits.
- * Returns array of -p values (one per split after the first item).
- *
- * Each tmux split divides the current pane. The percentage given to -p is
- * the portion allocated to the NEW (bottom/right) pane.
- */
-export declare function toSplitPercents(sizes: number[]): number[];

package/packages/daemon/dist/lib/skill-sync.d.ts

@@ -1,60 +0,0 @@
-/**
- * Claude Code's config dir: `TMUX_IDE_CLAUDE_DIR` when set (tests / per-run
- * overrides), else `~/.claude`. Mirrors the {@link ../tui/integrations/claude.ts}
- * settings override so both halves of the agent setup honor the same scratch dir.
- */
-export declare function claudeDir(): string;
-/** The fully-managed tmux-ide skill dir: `<claudeDir>/skills/tmux-ide`. */
-export declare function skillTargetDir(): string;
-/** The installed SKILL.md path (inside {@link skillTargetDir}). */
-export declare function skillTargetFile(): string;
-/**
- * io — the bundled SKILL.md that ships in the package. Resolved relative to this
- * module, handling BOTH the esbuild-bundled CLI (this file inlines into
- * `bin/cli.js`, so `here` is `bin/` and the skill is one level up) AND the dev
- * source tree (`packages/daemon/src/lib/`, four levels below the repo root) — the
- * same dual-candidate trick as {@link getCurrentVersion}. Returns the first that
- * exists, else the bundled-layout guess.
- */
-export declare function defaultSkillSource(): string;
-/**
- * The version marker line (an HTML comment on line 2 of SKILL.md). The sync
- * machinery reads it to know which version an installed copy is, and rewrites it
- * to the installed package version at copy time.
- */
-export declare const VERSION_MARKER_RE: RegExp;
-/** PURE — render the marker line for a given version. */
-export declare function versionMarker(version: string): string;
-/** PURE — the version in a SKILL.md body, or null when the marker is absent. */
-export declare function parseSkillVersion(content: string): string | null;
-/**
- * PURE — return `content` with its version marker rewritten to `version`. When no
- * marker is present the content is returned unchanged (the bundled SKILL.md
- * always carries one; this just never corrupts a hand-stripped file).
- */
-export declare function rewriteVersionMarker(content: string, version: string): string;
-/** The version marker read off an installed SKILL.md, or null if absent/unreadable. */
-export declare function installedSkillVersion(dir?: string): string | null;
-/** What a {@link syncSkill} did. */
-export interface SyncResult {
-    /** `installed` = target was absent; `updated` = content changed; `unchanged` = no-op. */
-    action: "installed" | "updated" | "unchanged";
-    /** The written SKILL.md path. */
-    path: string;
-    /** The installed version before an `updated` (the marker we replaced), if any. */
-    from?: string | null;
-    /** The version written into the copy's marker. */
-    to: string;
-}
-/**
- * io — copy the bundled SKILL.md into the managed skill dir with its version
- * marker rewritten to `version`. Content-driven and idempotent: the RENDERED
- * source (marker substituted) is compared byte-for-byte against the installed
- * copy — identical → `unchanged` (no write), absent → `installed`, otherwise
- * `updated`. Only ever writes inside {@link skillTargetDir}; nothing outside it
- * is read or touched.
- */
-export declare function syncSkill({ source, version, }?: {
-    source?: string;
-    version?: string;
-}): SyncResult;

package/packages/daemon/dist/lib/slugify.d.ts

@@ -1,4 +0,0 @@
-/**
- * Convert text to a URL/filename-safe slug.
- */
-export declare function slugify(text: string, maxLen?: number): string;

package/packages/daemon/dist/lib/state-home.d.ts

@@ -1,2 +0,0 @@
-/** Absolute path to the state home directory (not created here). */
-export declare function stateHome(): string;

package/packages/daemon/dist/lib/terminals-store.d.ts

@@ -1,27 +0,0 @@
-/**
- * Terminals registry (G20-P1).
- *
- * JSON-backed persistence for tab-strip metadata — names, scopes, and
- * kind. The actual PTY process lives in `PtyBridgeRegistry`; this
- * store only persists what the UI needs to restore tab labels across
- * reloads. Atomic writes (temp + rename) so a crash mid-write leaves
- * the previous list intact.
- */
-import type { Terminal, TerminalKind } from "@tmux-ide/contracts";
-/** Load the full list for a session. Missing file → empty list. */
-export declare function loadTerminals(dir: string): Terminal[];
-export interface CreateInput {
-    id: string;
-    projectId: string;
-    scopeId: string;
-    name: string;
-    kind: TerminalKind;
-    scripted?: boolean;
-}
-/** Insert OR replace a terminal record by id. Idempotent — calling
- *  `createTerminal` twice with the same deterministic id is a no-op
- *  on the canonical fields and updates `updatedAt`. */
-export declare function upsertTerminal(dir: string, input: CreateInput): Terminal;
-export declare function renameTerminal(dir: string, id: string, name: string): Terminal | null;
-export declare function deleteTerminal(dir: string, id: string): boolean;
-export declare function findTerminal(dir: string, id: string): Terminal | null;

package/packages/daemon/dist/lib/tui-binary.d.ts

@@ -1,57 +0,0 @@
-/** The `<os>-<arch>` tags we publish a prebuilt TUI binary for. */
-export type TuiPlatformTag = "darwin-arm64" | "darwin-x64" | "linux-x64" | "linux-arm64";
-/** The GitHub repo the release assets live under. */
-export declare const RELEASE_REPO = "wavyrai/tmux-ide";
-/** A downloaded binary smaller than this is treated as corrupt/truncated. */
-export declare const MIN_TUI_BINARY_BYTES: number;
-/**
- * PURE — map a Node `process.platform`/`process.arch` pair to the release tag,
- * or null when we don't publish a binary for it (e.g. windows, freebsd) so the
- * caller can fall back to the "install bun" message.
- */
-export declare function tuiPlatformTag(platform?: NodeJS.Platform, arch?: string): TuiPlatformTag | null;
-/** PURE — the `bun build --compile --target` flag for a tag (`bun-<tag>`). */
-export declare function bunTargetForTag(tag: TuiPlatformTag): string;
-/** PURE — the release asset filename for a tag (gzip-compressed binary). */
-export declare function releaseAssetName(tag: TuiPlatformTag): string;
-/** PURE — strip a leading `v` from a version string; `2.6.1` and `v2.6.1` both → `2.6.1`. */
-export declare function normalizeVersion(version: string): string;
-/**
- * PURE — the GitHub download URL for a platform's asset at a given version:
- * `https://github.com/<repo>/releases/download/v<version>/tmux-ide-tui-<tag>.gz`.
- */
-export declare function releaseAssetUrl(version: string, tag: TuiPlatformTag): string;
-/**
- * PURE — where a downloaded binary lives: `<home>/bin/tmux-ide-tui-<tag>-<version>`.
- * The version is stamped INTO the name so a `tmux-ide update` to a new version
- * misses the old download and re-fetches (rather than launching a stale binary).
- */
-export declare function downloadedTuiPath(home: string, tag: TuiPlatformTag, version: string): string;
-/**
- * io — the tmux-ide state home (`TMUX_IDE_HOME` override, else `~/.tmux-ide`),
- * the same resolution the update-check cache and welcome marker use.
- */
-export declare function tuiStateHome(): string;
-/**
- * io — locate a previously downloaded per-platform binary for THIS version and
- * platform, or null. Feeds the resolution order in `tui/compiled.ts` after the
- * shipped/local compiled binary and before the honest "unavailable" error.
- */
-export declare function findDownloadedTui(version?: string): string | null;
-/**
- * io — download, verify, and install the per-platform TUI binary for the running
- * version. Fetches the gzip asset, inflates it, rejects anything under
- * {@link MIN_TUI_BINARY_BYTES} (a truncated download or an HTML error page),
- * writes it `0o755`, and atomically renames it into place (temp-in-same-dir →
- * rename, so a crashed download never leaves a half-written executable).
- *
- * Throws with an actionable message on an unsupported platform or a failed
- * fetch. Returns the installed path and byte size.
- */
-export declare function downloadTuiBinary(opts?: {
-    version?: string;
-    log?: (msg: string) => void;
-}): Promise<{
-    path: string;
-    bytes: number;
-}>;