@xfey/tutti 0.1.28 → 0.1.30

package/dist/server-shell/cli/project-resolver.js

@@ -1,21 +1,12 @@
-import { existsSync, readdirSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import { basename, resolve } from "node:path";
 import { ID_PREFIXES, isPrefixedId } from "@tutti/shared/ids";
 import { readOpenAiProviderConfigProjection, readProjectOpenAiProviderConfig, resolveTuttiHome, } from "../../providers/openai/index.js";
 import { LaunchError } from "./errors.js";
 import { assertSafeProjectRoot } from "./git-bootstrap.js";
+import { inspectMachineProjectInventory, inspectMachineProjectInventories, } from "./machine-project-inspector.js";
 import { readMachineProjectBinding, readMachineRuntimeEndpoint, } from "./machine-local.js";
 import { readProjectDisplayName, readProjectIdentity } from "./project-identity.js";
-function projectIdsFromTuttiHome(tuttiHome) {
-    const projectsRoot = join(tuttiHome, "projects");
-    if (!existsSync(projectsRoot)) {
-        return [];
-    }
-    return readdirSync(projectsRoot, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory() && isPrefixedId(entry.name, ID_PREFIXES.project))
-        .map((entry) => entry.name)
-        .sort();
-}
 function readRuntimeEndpoint(tuttiHome, projectId) {
     try {
         return readMachineRuntimeEndpoint(tuttiHome, projectId);
@@ -32,33 +23,33 @@ function readBinding(tuttiHome, projectId) {
         return null;
     }
 }
-function readProjectTargetEntry(tuttiHome, projectId) {
-    const binding = readBinding(tuttiHome, projectId);
-    const endpoint = readRuntimeEndpoint(tuttiHome, projectId);
-    const workspaceRoot = binding?.workspace_root ?? endpoint?.workspace_root;
+function projectTargetEntryFromInspection(inspection) {
+    const workspaceRoot = inspection.workspace_root;
     if (workspaceRoot === undefined) {
         return null;
     }
-    const workspaceName = basename(workspaceRoot) || projectId;
-    const displayName = readProjectDisplayName(workspaceRoot) ?? workspaceName;
-    const aliases = Array.from(new Set([displayName, workspaceName].filter((alias) => alias.trim() !== "")));
+    const workspaceName = basename(workspaceRoot) || inspection.project_id;
+    const aliases = inspection.workspace.kind === "matching"
+        ? Array.from(new Set([inspection.display_name, workspaceName].filter((alias) => alias.trim() !== "")))
+        : [];
     return {
-        project_id: projectId,
+        project_id: inspection.project_id,
         workspace_root: workspaceRoot,
-        display_name: displayName,
+        display_name: inspection.display_name,
         aliases,
+        workspace_state: inspection.workspace.kind,
     };
 }
 function listProjectTargetEntries(tuttiHome) {
-    return projectIdsFromTuttiHome(tuttiHome)
-        .map((projectId) => readProjectTargetEntry(tuttiHome, projectId))
+    return inspectMachineProjectInventories(tuttiHome)
+        .map(projectTargetEntryFromInspection)
         .filter((entry) => entry !== null);
 }
 function normalizeTargetName(value) {
     return value.trim().toLowerCase();
 }
 function formatTargetMatch(entry) {
-    return `${entry.project_id}  ${entry.display_name}  ${entry.workspace_root}`;
+    return `${entry.project_id}  ${entry.workspace_state}  ${entry.display_name}`;
 }
 function resolveSingleTargetMatch(target, matches) {
     if (matches.length === 1) {
@@ -81,15 +72,13 @@ function resolveProjectTargetEntry(options) {
     if (existsSync(pathCandidate)) {
         return readProjectTargetEntryFromWorkspace(pathCandidate);
     }
-    const entries = listProjectTargetEntries(options.tuttiHome);
-    const pathMatches = entries.filter((entry) => resolve(entry.workspace_root) === pathCandidate);
-    if (pathMatches.length > 0) {
-        return resolveSingleTargetMatch(target, pathMatches);
-    }
-    const exactId = entries.filter((entry) => entry.project_id === target);
-    if (exactId.length > 0) {
-        return resolveSingleTargetMatch(target, exactId);
+    if (isPrefixedId(target, ID_PREFIXES.project)) {
+        const exactEntry = projectTargetEntryFromInspection(inspectMachineProjectInventory(target, options.tuttiHome));
+        if (exactEntry !== null) {
+            return exactEntry;
+        }
     }
+    const entries = listProjectTargetEntries(options.tuttiHome);
     if (target.startsWith(ID_PREFIXES.project)) {
         const idPrefix = entries.filter((entry) => entry.project_id.startsWith(target));
         if (idPrefix.length > 0) {
@@ -113,6 +102,7 @@ function readProjectTargetEntryFromWorkspace(workspaceRoot) {
         workspace_root: workspaceRoot,
         display_name: displayName,
         aliases: Array.from(new Set([displayName, workspaceName].filter((alias) => alias.trim() !== ""))),
+        workspace_state: "matching",
     };
 }
 export function resolveLaunchWorkspacePath(options) {

package/dist/server-shell/cli/relay-registration.d.ts

@@ -1,5 +1,5 @@
 import { type ConnectRelayHostTunnelOptions, type RelayHostTunnelHandle, type RegisterRelayHostConnectionOptions, type RegisterRelayHostConnectionResponse } from "@tutti/relay-client";
-import type { HostConnectionRef, RelayProjectRef } from "@tutti/shared/ids";
+import { type HostConnectionRef, type RelayProjectRef } from "@tutti/shared/ids";
 import { LaunchError } from "./errors.js";
 import type { LaunchPreparationResult } from "./launch.js";
 type FetchLike = (input: string | URL, init?: RequestInit) => Promise<Response>;
@@ -19,12 +19,15 @@ export type RegisteredRelayHostConnection = {
     summary: HostLaunchRelaySummary;
     hostConnectionToken: string;
 };
+export type HostRelayRegistrationPreparation = Pick<LaunchPreparationResult, "tutti_home" | "project_id" | "workspace_root" | "relay_url">;
 export declare function relayErrorToLaunchError(error: unknown, relayUrl: string): LaunchError;
 export declare function registerHostWithRelay(options: {
-    preparation: LaunchPreparationResult;
+    preparation: HostRelayRegistrationPreparation;
     fetchImpl: FetchLike;
     registerRelayHostConnection: RelayHostConnectionRegistrar;
     serverVersion: string;
+    joinTokenMode?: "reuse_active" | "rotate";
+    signal?: AbortSignal;
     now?: () => Date;
 }): Promise<RegisteredRelayHostConnection>;
 export {};

package/dist/server-shell/cli/relay-registration.js

@@ -1,5 +1,6 @@
 import { basename } from "node:path";
 import { RelayHostControlClientError, } from "@tutti/relay-client";
+import { createIdempotencyKey, } from "@tutti/shared/ids";
 import { readHostRegistrationSecret, updateMachineProjectRelayBinding } from "./machine-local.js";
 import { LaunchError } from "./errors.js";
 import { readProjectDisplayName } from "./project-identity.js";
@@ -26,8 +27,10 @@ export async function registerHostWithRelay(options) {
         displayName: readProjectDisplayName(options.preparation.workspace_root) ??
             (basename(options.preparation.workspace_root) || options.preparation.project_id),
         serverVersion: options.serverVersion,
-        joinToken: { mode: "rotate" },
+        commandId: createIdempotencyKey(),
+        joinToken: { mode: options.joinTokenMode ?? "rotate" },
         fetch: options.fetchImpl,
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
         ...(options.now === undefined ? {} : { issuedAt: options.now() }),
     };
     const response = await options.registerRelayHostConnection(registrationOptions);
@@ -35,7 +38,8 @@ export async function registerHostWithRelay(options) {
         throw new LaunchError("relay_registration_failed", "Relay host registration did not complete", "Retry `tutti launch` with a new registration command.");
     }
     const result = response.result;
-    if (result.join_token.visibility !== "visible_once" || result.join_token.join_url === undefined) {
+    if ((options.joinTokenMode ?? "rotate") === "rotate" &&
+        (result.join_token.visibility !== "visible_once" || result.join_token.join_url === undefined)) {
         throw new LaunchError("relay_registration_failed", "Relay did not return a visible join URL for this launch", "Retry `tutti launch` so the host can rotate a fresh visible-once join URL.");
     }
     updateMachineProjectRelayBinding({
@@ -48,7 +52,7 @@ export async function registerHostWithRelay(options) {
         summary: {
             relay_project_ref: result.relay_project.relay_project_ref,
             host_connection_ref: result.host_connection.host_connection_ref,
-            join_url: result.join_token.join_url,
+            ...(result.join_token.join_url === undefined ? {} : { join_url: result.join_token.join_url }),
             join_url_visibility: result.join_token.visibility,
             join_token_expires_at: result.join_token.expires_at,
             join_token_reusable: result.join_token.reusable,

package/dist/server-shell/cli/runtime-commands.d.ts

@@ -1,40 +1,66 @@
-import { type ProjectId } from "@tutti/shared/ids";
+import type { ProjectId } from "@tutti/shared/ids";
 import { type FetchLike } from "./host-runtime-endpoint.js";
 import { type MachineRuntimeEndpointRecord } from "./machine-local.js";
 import type { LocalControlFetch } from "./local-control-client.js";
 export type RuntimeProjectRow = {
     project_id: ProjectId;
-    status: "online" | "offline" | "stale";
+    status: "online" | "reconnecting" | "relay-unavailable" | "stale" | "stopped" | "workspace-missing" | "workspace-replaced" | "invalid";
     display_name: string;
     workspace_root: string;
     endpoint?: string;
     provider_status?: string;
     relay_project_ref?: string;
     join_url?: string;
+    relay_connection_status?: string;
+    last_connected_at?: string;
+    next_retry_at?: string;
+    relay_reason_code?: string;
 };
 export declare function formatProjectIdForDisplay(projectId: ProjectId, projectIds: readonly ProjectId[]): string;
 export declare function listRuntimeProjects(options?: {
     env?: NodeJS.ProcessEnv;
     cwd?: string;
     fetchImpl?: FetchLike;
+    all?: boolean;
 }): Promise<RuntimeProjectRow[]>;
-export declare function runPsCommand(): Promise<string>;
+export declare function runPsCommand(options?: Parameters<typeof listRuntimeProjects>[0]): Promise<string>;
 export declare function runPsManageCommand(options?: {
     stdin?: NodeJS.ReadStream;
     stdout?: NodeJS.WriteStream;
+    all?: boolean;
 }): Promise<void>;
 export declare function runStopCommand(target?: string, options?: {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
     fetchImpl?: LocalControlFetch;
 }): Promise<string>;
+export declare function runArchiveCommand(target: string, options?: {
+    yes?: boolean;
+    interactive?: boolean;
+    confirm?: (message: string) => Promise<boolean>;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: LocalControlFetch;
+    shutdownWaitMs?: number;
+    now?: () => Date;
+}): Promise<string>;
+export declare function runForgetCommand(target: string, options?: {
+    yes?: boolean;
+    interactive?: boolean;
+    confirm?: (message: string) => Promise<boolean>;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: LocalControlFetch;
+    shutdownWaitMs?: number;
+}): Promise<string>;
 export declare function runInviteCommand(target?: string): Promise<string>;
 export declare function runProviderStatusCommand(target?: string): string;
 export declare function runLogsCommand(target?: string, tailLines?: number): string;
 export declare function runDoctorCommand(target?: string, options?: {
     cwd?: string;
     env?: NodeJS.ProcessEnv;
-}): string;
+    fetchImpl?: LocalControlFetch;
+}): Promise<string>;
 export declare function readRuntimeEndpointForProject(tuttiHome: string, projectId: ProjectId): MachineRuntimeEndpointRecord | null;
 export declare function runtimeEndpointPathForProject(tuttiHome: string, projectId: ProjectId): string;
 export declare function projectLocalStoreRoot(tuttiHome: string, projectId: ProjectId): string;