@nurix/nustack 0.10.0-dev.10

package/dist/commands/workspace.js

@@ -0,0 +1,479 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import * as p from "@clack/prompts";
+import { createWorkspaceViaAsk, getWorkspace, listWorkspaces, listOrganizations, publishWorkspace, resolveNuStackUrl, unpublishWorkspace, } from "../lib/nustack_client.js";
+import { ensureAccessToken } from "../lib/auth_grant.js";
+import { ensureAuthWithRecovery, lastAuthFailure } from "../lib/auth_recovery.js";
+import { resolveWorkspaceId, resolveOrganizationId } from "../lib/workspace_context.js";
+import { readActiveOrganizationContext } from "./organization.js";
+import { confirmOrFallback, isInteractive } from "../lib/interactive.js";
+import { launchBrowser } from "../lib/browser_opener.js";
+import { assertSafeBrowserUrl } from "../lib/guards.js";
+import { openLocalStore } from "../lib/local_store/database.js";
+import { readDeviceState } from "../lib/local_store/device_state.js";
+import { getBindingByRepositoryRoot, listBindings } from "../lib/local_store/bindings.js";
+import { resolveRepository } from "../lib/git-sync/core/repository.js";
+import { readWorkspaceManifests } from "../lib/onboarding/manifest_writer.js";
+import { hasManifest, scaffoldManifest } from "../lib/manifest.js";
+import { toolkitCompatibility } from "../lib/etna/reconcile.js";
+import { attachExistingGit } from "../lib/onboarding/attach_existing_git.js";
+import { webFirstAttach } from "../lib/onboarding/web_first_attach.js";
+import { printJsonError, printJsonSuccess } from "../lib/json_output.js";
+function emitFail(command, json, code, message) {
+    if (json)
+        printJsonError(command, { code, message });
+    else {
+        console.error(message);
+        process.exitCode = 1;
+    }
+}
+async function requireAuth(command, json, globals) {
+    const baseUrl = resolveNuStackUrl(globals);
+    const deviceAuth = await ensureAuthWithRecovery(baseUrl, json);
+    if (!deviceAuth) {
+        const failure = lastAuthFailure();
+        emitFail(command, json, failure.code, failure.message);
+        return null;
+    }
+    return { baseUrl, accessToken: deviceAuth.accessToken };
+}
+async function resolveOrganizationForWorkspace(auth, options) {
+    const memberships = await listOrganizations(auth.baseUrl, auth.accessToken);
+    const views = memberships.map((m) => ({ id: m.organization.id, slug: m.organization.slug }));
+    const active = await readActiveOrganizationContext();
+    const resolution = resolveOrganizationId({ organization: options.organization }, active, views);
+    return resolution.ok ? { ok: true, organizationId: resolution.organizationId } : { ok: false, message: resolution.message };
+}
+export async function runWorkspaceList(options, globals) {
+    const json = options.json === true;
+    const auth = await requireAuth("workspace list", json, globals);
+    if (!auth)
+        return;
+    const ws = await resolveOrganizationForWorkspace(auth, options);
+    if (!ws.ok) {
+        emitFail("workspace list", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
+        return;
+    }
+    const workspaces = await listWorkspaces(auth.baseUrl, auth.accessToken, ws.organizationId);
+    if (json) {
+        printJsonSuccess("workspace list", { organizationId: ws.organizationId, workspaces });
+        return;
+    }
+    if (workspaces.length === 0) {
+        console.log("No Workspaces in this Organization. Create one with `nustack workspace create`.");
+        return;
+    }
+    for (const workspace of workspaces) {
+        console.log(`${workspace.id.padEnd(24)} ${workspace.status.padEnd(12)} ${workspace.publicationState.padEnd(12)} ${workspace.label}`);
+    }
+}
+export async function runWorkspaceCreate(options, globals) {
+    const json = options.json === true;
+    const auth = await requireAuth("workspace create", json, globals);
+    if (!auth)
+        return;
+    const ws = await resolveOrganizationForWorkspace(auth, options);
+    if (!ws.ok) {
+        emitFail("workspace create", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
+        return;
+    }
+    const gathered = await gatherCreatePrompt(options, json);
+    if (!gathered.ok) {
+        emitFail("workspace create", json, "VALIDATION_FAILED", gathered.message);
+        return;
+    }
+    const workspace = await createWorkspaceFromPrompt(auth, ws.organizationId, gathered.prompt, "workspace create", json);
+    if (!workspace)
+        return;
+    if (json) {
+        printJsonSuccess("workspace create", { workspace, organizationId: ws.organizationId });
+        return;
+    }
+    console.log(`Created Workspace ${workspace.label} (${workspace.id}), status ${workspace.status}.`);
+    console.log(`Attach a local folder with \`nustack workspace attach --workspace ${workspace.id}\`.`);
+    if (isInteractive() && (await confirmOrFallback("Attach the current folder to this Workspace now?", false))) {
+        const store = await openLocalStore();
+        try {
+            const ctx = buildOnboardingContext(auth, store, json, options.yes === true);
+            const outcome = await webFirstAttach(ctx, {
+                workspaceId: workspace.id,
+                organizationId: ws.organizationId,
+                confirmPopulated: options.yes === true,
+            });
+            reportWebFirst("workspace create", outcome, json);
+        }
+        finally {
+            store.close();
+        }
+    }
+}
+export async function runWorkspaceAttach(options, globals) {
+    const json = options.json === true;
+    const auth = await requireAuth("workspace attach", json, globals);
+    if (!auth)
+        return;
+    const store = await openLocalStore();
+    try {
+        const ctx = buildOnboardingContext(auth, store, json, options.yes === true);
+        if (options.workspace) {
+            const ws = await resolveOrganizationForWorkspace(auth, options);
+            if (!ws.ok) {
+                emitFail("workspace attach", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
+                return;
+            }
+            const outcome = await webFirstAttach(ctx, {
+                workspaceId: options.workspace,
+                organizationId: ws.organizationId,
+                confirmPopulated: options.yes === true,
+            });
+            reportWebFirst("workspace attach", outcome, json);
+            return;
+        }
+        let root;
+        try {
+            root = resolveRepository(ctx.cwd).repositoryRoot;
+        }
+        catch {
+            emitFail("workspace attach", json, "NOT_A_WORKTREE", "`nustack workspace attach` needs a Git worktree — run `nustack init` to establish one, or pass `--workspace <id>` for a web-created Workspace.");
+            return;
+        }
+        const resolved = await resolveOrCreateWorkspaceForAttach(auth, options, root, json);
+        if (!resolved.ok)
+            return;
+        if (!hasManifest(root))
+            await scaffoldManifest(root, deriveSlug(path.basename(root)));
+        const outcome = await attachExistingGit(ctx, {
+            workspaceId: resolved.workspaceId,
+            organizationId: resolved.organizationId,
+            confirmRebind: options.yes === true,
+        });
+        reportAttach("workspace attach", outcome, json);
+    }
+    finally {
+        store.close();
+    }
+}
+export async function runWorkspaceStatus(options, globals) {
+    const json = options.json === true;
+    const cwd = process.cwd();
+    const workspace = await resolveWorkspaceId(cwd, { workspace: options.workspace });
+    if (!workspace.ok) {
+        emitFail("workspace status", json, "WORKSPACE_CONTEXT_MISSING", workspace.message);
+        return;
+    }
+    const baseUrl = resolveNuStackUrl(globals);
+    const auth = await ensureAccessToken(baseUrl).catch(() => null);
+    const store = await openLocalStore();
+    let binding = null;
+    try {
+        binding = findBindingForWorkspace(store, workspace.workspaceId, cwd);
+    }
+    finally {
+        store.close();
+    }
+    let cloudWorkspace = null;
+    let cloud = null;
+    if (auth) {
+        try {
+            cloudWorkspace = await getWorkspace(baseUrl, auth.accessToken, workspace.workspaceId);
+            if (cloudWorkspace.toolkit && cloudWorkspace.toolkit.version && cloudWorkspace.toolkit.rendererVersion && cloudWorkspace.toolkit.placementMapVersion) {
+                cloud = {
+                    name: cloudWorkspace.toolkit.name,
+                    version: cloudWorkspace.toolkit.version,
+                    rendererVersion: cloudWorkspace.toolkit.rendererVersion,
+                    placementMapVersion: cloudWorkspace.toolkit.placementMapVersion,
+                    catalogVersionId: null,
+                };
+            }
+        }
+        catch {
+            cloudWorkspace = null;
+        }
+    }
+    const compatibility = toolkitCompatibility(binding ?? { etnaProfileJson: null }, cloud);
+    if (json) {
+        printJsonSuccess("workspace status", {
+            workspaceId: workspace.workspaceId,
+            cloudReachable: cloudWorkspace !== null,
+            cloud: cloudWorkspace
+                ? { label: cloudWorkspace.label, status: cloudWorkspace.status, publicationState: cloudWorkspace.publicationState, initStatus: cloudWorkspace.initStatus }
+                : null,
+            binding: binding
+                ? {
+                    id: binding.id,
+                    boundBranch: binding.boundBranch,
+                    lastProcessedCommitId: binding.lastProcessedCommitId,
+                    lastAppliedWorkspaceSequence: binding.lastAppliedWorkspaceSequence,
+                    status: binding.status,
+                }
+                : null,
+            toolkit: { compatible: compatibility.compatible, blocksWrites: compatibility.blocksWrites, reason: compatibility.reason },
+        });
+        return;
+    }
+    console.log(`Workspace ${workspace.workspaceId}`);
+    console.log(`  cloud:    ${cloudWorkspace ? `${cloudWorkspace.label} — ${cloudWorkspace.status} / ${cloudWorkspace.publicationState}` : "(unreachable — local-only view)"}`);
+    if (binding) {
+        console.log(`  binding:  ${binding.id} on ${binding.boundBranch} (${binding.status})`);
+        console.log(`  cursor:   processed=${binding.lastProcessedCommitId?.slice(0, 12) ?? "—"}  applied@${binding.lastAppliedWorkspaceSequence}`);
+    }
+    else {
+        console.log("  binding:  (this folder is not bound on this device)");
+    }
+    console.log(`  toolkit:  ${compatibility.blocksWrites ? `BLOCKED — ${compatibility.reason}` : "clear (projection and sync writes allowed)"}`);
+}
+export async function runWorkspaceOpen(options, globals) {
+    const json = options.json === true;
+    const workspace = await resolveWorkspaceId(process.cwd(), { workspace: options.workspace });
+    if (!workspace.ok) {
+        emitFail("workspace open", json, "WORKSPACE_CONTEXT_MISSING", workspace.message);
+        return;
+    }
+    const baseUrl = resolveNuStackUrl(globals);
+    let url;
+    try {
+        url = assertSafeBrowserUrl(`${baseUrl}/workspaces/${encodeURIComponent(workspace.workspaceId)}`);
+    }
+    catch (error) {
+        emitFail("workspace open", json, "UNSAFE_URL", error instanceof Error ? error.message : String(error));
+        return;
+    }
+    if (json) {
+        printJsonSuccess("workspace open", { workspaceId: workspace.workspaceId, url });
+        return;
+    }
+    launchBrowser(url);
+    console.log(`Opening ${url}`);
+}
+export async function runWorkspacePublish(options, globals) {
+    return runPublication("publish", "workspace publish", options, globals);
+}
+export async function runWorkspaceUnpublish(options, globals) {
+    return runPublication("unpublish", "workspace unpublish", options, globals);
+}
+async function runPublication(action, command, options, globals) {
+    const json = options.json === true;
+    const auth = await requireAuth(command, json, globals);
+    if (!auth)
+        return;
+    const workspace = await resolveWorkspaceId(process.cwd(), { workspace: options.workspace });
+    if (!workspace.ok) {
+        emitFail(command, json, "WORKSPACE_CONTEXT_MISSING", workspace.message);
+        return;
+    }
+    try {
+        if (action === "publish")
+            await publishWorkspace(auth.baseUrl, auth.accessToken, workspace.workspaceId, {}, randomUUID());
+        else
+            await unpublishWorkspace(auth.baseUrl, auth.accessToken, workspace.workspaceId, randomUUID());
+    }
+    catch (error) {
+        emitFail(command, json, action === "publish" ? "PUBLISH_FAILED" : "UNPUBLISH_FAILED", error instanceof Error ? error.message : String(error));
+        return;
+    }
+    if (json) {
+        printJsonSuccess(command, { workspaceId: workspace.workspaceId, publicationState: action === "publish" ? "public" : "private" });
+        return;
+    }
+    console.log(action === "publish" ? `Published Workspace ${workspace.workspaceId}.` : `Unpublished Workspace ${workspace.workspaceId}.`);
+}
+function buildOnboardingContext(auth, store, json, yes) {
+    const deviceState = readDeviceState(store);
+    return {
+        store,
+        baseUrl: auth.baseUrl,
+        accessToken: auth.accessToken,
+        deviceRef: deviceState?.deviceRef ?? "",
+        userId: deviceState?.activeUserId ?? null,
+        cwd: process.cwd(),
+        json,
+        yes,
+        interactive: isInteractive(),
+    };
+}
+async function gatherCreatePrompt(options, json) {
+    const flagPrompt = options.prompt?.trim();
+    if (flagPrompt)
+        return { ok: true, prompt: flagPrompt };
+    const name = options.name?.trim();
+    if (name)
+        return { ok: true, prompt: `Create a workspace named "${name}".` };
+    if (json || !isInteractive()) {
+        return { ok: false, message: "A prompt is required — pass `--prompt <text>` (or `--name <name>`)." };
+    }
+    const answer = await p.text({ message: "What should this workspace be?" });
+    if (p.isCancel(answer) || !String(answer).trim())
+        return { ok: false, message: "A prompt is required." };
+    return { ok: true, prompt: String(answer).trim() };
+}
+async function createWorkspaceFromPrompt(auth, organizationId, prompt, command, json) {
+    let outcome;
+    try {
+        outcome = await createWorkspaceViaAsk(auth.baseUrl, auth.accessToken, organizationId, prompt, {
+            onPhase: json ? undefined : (message) => p.log.info(message),
+        });
+    }
+    catch (error) {
+        emitFail(command, json, "WORKSPACE_CREATE_FAILED", error instanceof Error ? error.message : String(error));
+        return null;
+    }
+    if (outcome.generationError && !json) {
+        p.log.warn(`The first document did not finish: ${outcome.generationError}`);
+    }
+    return getWorkspace(auth.baseUrl, auth.accessToken, outcome.workspaceId);
+}
+async function resolveOrCreateWorkspaceForAttach(auth, options, root, json) {
+    const marker = await resolveWorkspaceId(root, {});
+    if (marker.ok) {
+        const manifests = await readWorkspaceManifests(root);
+        const markerOrganization = manifests.workspaceManifest?.organizationId ?? manifests.serviceWorkspaceBinding?.organizationId ?? null;
+        if (markerOrganization)
+            return { ok: true, workspaceId: marker.workspaceId, organizationId: markerOrganization };
+        const ws = await resolveOrganizationForWorkspace(auth, options);
+        if (!ws.ok) {
+            emitFail("workspace attach", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
+            return { ok: false };
+        }
+        return { ok: true, workspaceId: marker.workspaceId, organizationId: ws.organizationId };
+    }
+    const ws = await resolveOrganizationForWorkspace(auth, options);
+    if (!ws.ok) {
+        emitFail("workspace attach", json, "ORGANIZATION_CONTEXT_MISSING", ws.message);
+        return { ok: false };
+    }
+    const gathered = await gatherCreatePrompt(options, json);
+    if (!gathered.ok) {
+        emitFail("workspace attach", json, "WORKSPACE_CONTEXT_MISSING", `No Workspace to attach — ${gathered.message} Or pass \`--workspace <id>\` for a web-created Workspace.`);
+        return { ok: false };
+    }
+    const workspace = await createWorkspaceFromPrompt(auth, ws.organizationId, gathered.prompt, "workspace attach", json);
+    if (!workspace)
+        return { ok: false };
+    return { ok: true, workspaceId: workspace.id, organizationId: ws.organizationId };
+}
+function findBindingForWorkspace(store, workspaceId, cwd) {
+    try {
+        const byRoot = getBindingByRepositoryRoot(store, resolveRepository(cwd).repositoryRoot);
+        if (byRoot)
+            return byRoot;
+    }
+    catch {
+    }
+    return listBindings(store).find((binding) => binding.workspaceId === workspaceId) ?? null;
+}
+function deriveSlug(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "workspace";
+}
+function toResultJson(result) {
+    return {
+        flow: result.flow,
+        workspaceId: result.workspaceId,
+        organizationId: result.organizationId,
+        bindingId: result.bindingId,
+        boundBranch: result.boundBranch,
+        baselineCommitId: result.baselineCommitId,
+        toolkit: result.toolkit,
+        reused: result.reused,
+        install: { ok: result.install.ok, installed: result.install.installed, skipped: result.install.skipped },
+        noPush: result.noPush,
+    };
+}
+function printOnboardingHuman(result) {
+    console.log(`Bound Workspace ${result.workspaceId} on branch ${result.boundBranch} (binding ${result.bindingId})${result.reused ? " [reused]" : ""}.`);
+    const installNote = result.install.skipped
+        ? result.install.reason ?? "no install"
+        : result.install.installed
+            ? "installed"
+            : "not installed";
+    console.log(`Toolkit ${result.toolkit.name}@${result.toolkit.version} — ${installNote}.`);
+    console.log("NuStack did not push any Git history.");
+}
+function reportWebFirst(command, outcome, json) {
+    if (!outcome.ok) {
+        emitFail(command, json, outcome.code, outcome.message);
+        return;
+    }
+    const result = outcome.result;
+    if (json) {
+        printJsonSuccess(command, {
+            ...toResultJson(result),
+            appliedCommitId: result.appliedCommitId,
+            changedPaths: result.changedPaths,
+            handoffId: result.handoffId,
+            overwriteRequired: result.overwriteRequired,
+            divergent: result.divergent,
+        });
+        return;
+    }
+    printOnboardingHuman(result);
+    if (result.overwriteRequired) {
+        console.log(`Divergent target(s) — nothing was changed. Review, then run \`nustack workspace sync approve ${result.handoffId ?? ""}\`:`);
+        for (const entry of result.divergent)
+            console.log(`  ${entry.path} (${entry.divergence})`);
+    }
+    else if (result.appliedCommitId) {
+        console.log(`Applied Handoff ${result.handoffId ?? ""} as ${result.appliedCommitId.slice(0, 12)} — NuStack did not push it.`);
+    }
+}
+function reportAttach(command, outcome, json) {
+    if (!outcome.ok) {
+        emitFail(command, json, outcome.code, outcome.message);
+        return;
+    }
+    if (json) {
+        printJsonSuccess(command, toResultJson(outcome.result));
+        return;
+    }
+    printOnboardingHuman(outcome.result);
+}
+export function registerWorkspaceCommands(workspaceCommand, getGlobalOptions) {
+    workspaceCommand
+        .command("list")
+        .description("List the Workspaces in the active (or --organization) Organization")
+        .option("--organization <id>", "the Organization to list (defaults to the active Organization)")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runWorkspaceList(options, getGlobalOptions()));
+    workspaceCommand
+        .command("create")
+        .description("Create a Workspace from a prompt, then optionally attach the current folder")
+        .option("--organization <id>", "the owning Organization (defaults to the active Organization)")
+        .option("--prompt <text>", "what the Workspace should be — the first prompt creates it")
+        .option("--name <name>", "shorthand: builds the create prompt from a name")
+        .option("--yes", "assume yes for onboarding confirmations")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runWorkspaceCreate(options, getGlobalOptions()));
+    workspaceCommand
+        .command("attach")
+        .description("Bind the current folder to a Workspace (existing-Git flow, or --workspace for a web-created Workspace)")
+        .option("--workspace <id>", "attach to this web-created Workspace (web-first flow)")
+        .option("--organization <id>", "the owning Organization (defaults to the active Organization)")
+        .option("--prompt <text>", "the create prompt when creating a Workspace for this worktree")
+        .option("--name <name>", "shorthand: builds the create prompt from a name")
+        .option("--yes", "confirm populated-folder onboarding and rebind")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runWorkspaceAttach(options, getGlobalOptions()));
+    workspaceCommand
+        .command("status")
+        .description("Show the cloud Workspace summary merged with the local binding (degraded offline)")
+        .option("--workspace <id>", "the Workspace to act as (defaults to the bound repository)")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runWorkspaceStatus(options, getGlobalOptions()));
+    workspaceCommand
+        .command("open")
+        .description("Open the Workspace in the browser (--json prints the URL instead of launching)")
+        .option("--workspace <id>", "the Workspace to open (defaults to the bound repository)")
+        .option("--json", "print the resolved URL as the machine envelope instead of launching")
+        .action(async (options) => runWorkspaceOpen(options, getGlobalOptions()));
+    workspaceCommand
+        .command("publish")
+        .description("Publish the Workspace (role-gated)")
+        .option("--workspace <id>", "the Workspace to publish (defaults to the bound repository)")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runWorkspacePublish(options, getGlobalOptions()));
+    workspaceCommand
+        .command("unpublish")
+        .description("Return the Workspace to private (role-gated)")
+        .option("--workspace <id>", "the Workspace to unpublish (defaults to the bound repository)")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runWorkspaceUnpublish(options, getGlobalOptions()));
+}