@useorgx/wizard 0.1.12 → 0.1.14

package/README.md

@@ -22,7 +22,7 @@ The wizard modifies local tool configuration only. Depending on the command, it
 
 ## Commands
 
-- `setup` adds OrgX MCP configs, standalone skills/rules, and companion plugins to detected AI tools. When OrgX auth is available in an interactive shell, it also guides workspace selection or creation, optional onboarding extras, and optional companion plugin installs for detected Cursor, Claude Code, Codex, and OpenClaw hosts. The founder preset preplans plugin installs before it writes standalone skills so plugin-backed hosts do not get duplicate standalone assets in the same run.
+- `setup` adds OrgX MCP configs, standalone skills/rules, and companion plugins to detected AI tools. When OrgX auth is available in an interactive shell, it guides workspace selection or creation, can create the user's first live OrgX initiative, creates a starter onboarding task under that initiative, and prints a handoff prompt for the configured AI tool of choice. The founder preset preplans plugin installs before it writes standalone skills so plugin-backed hosts do not get duplicate standalone assets in the same run.
 - `surface list` shows supported surfaces and current status.
 - `surface add <name>` patches a specific surface.
 - `surface remove <name>` removes OrgX-managed config from a specific surface.
@@ -60,6 +60,8 @@ The wizard modifies local tool configuration only. Depending on the command, it
 ## Workspace Bootstrap
 
 - `wizard setup` now opens a guided workspace picker in interactive shells, letting you keep the current default workspace, promote another existing workspace, or create a new one and make it active immediately.
+- If the selected workspace has no remembered setup initiative, `wizard setup` offers to create a first initiative, defaulting to `Make OrgX useful on this machine`. It then creates the onboarding workstream and starter task inside that initiative so setup ends with a concrete next action instead of a blank workspace.
+- After the first initiative is ready, setup prints the `/live/<initiative>` URL and a copyable prompt for the user's configured AI tool: continue the initiative, show the next action, and start with the onboarding task.
 - `wizard workspace current` reads the current OrgX workspace from `GET /api/v1/workspaces/current`, with a fallback to workspace listing if that route is unavailable.
 - `wizard workspace list` lists all accessible workspaces.
 - `wizard workspace create "Founders" --description "Initial OrgX workspace"` creates a new workspace through `POST /api/entities`.

package/dist/cli.js

@@ -519,9 +519,6 @@ function normalizeOrgxBaseUrl(raw) {
 }
 function buildOrgxApiUrl(path, baseUrl) {
   const parsedBase = new URL(normalizeOrgxBaseUrl(baseUrl));
-  if (parsedBase.protocol === "https:" && normalizeHost(parsedBase.hostname) === "useorgx.com") {
-    parsedBase.hostname = "www.useorgx.com";
-  }
   const normalizedBase = parsedBase.toString().replace(/\/+$/, "");
   const apiBase = normalizedBase.endsWith("/api") ? normalizedBase : `${normalizedBase}/api`;
   const normalizedPath = path.startsWith("/") ? path : `/${path}`;
@@ -726,6 +723,21 @@ async function fetchJson({
   }
   return payload;
 }
+var UNROUTABLE_HOSTNAMES = /* @__PURE__ */ new Set(["0.0.0.0", "::", "[::]"]);
+function sanitizeConnectUrl(connectUrl, baseUrl) {
+  try {
+    const parsed = new URL(connectUrl);
+    if (UNROUTABLE_HOSTNAMES.has(parsed.hostname)) {
+      const base = new URL(normalizeOrgxBaseUrl(baseUrl));
+      parsed.protocol = base.protocol;
+      parsed.hostname = base.hostname;
+      parsed.port = base.port;
+    }
+    return parsed.toString();
+  } catch {
+    return connectUrl;
+  }
+}
 function parsePairingStartResult(value) {
   if (!isRecord(value)) {
     throw new Error("OrgX pairing start returned an invalid response.");
@@ -777,7 +789,11 @@ async function startBrowserPairing(options, fetchImpl) {
     }),
     fetchImpl
   });
-  return parsePairingStartResult(data);
+  const result = parsePairingStartResult(data);
+  return {
+    ...result,
+    connectUrl: sanitizeConnectUrl(result.connectUrl, options.baseUrl)
+  };
 }
 async function pollBrowserPairing(options, fetchImpl) {
   const baseUrl = normalizeOrgxBaseUrl(options.baseUrl);
@@ -930,6 +946,24 @@ function parseDemoInitiative(value) {
     ...isNonEmptyString2(record.workspaceName) ? { workspaceName: record.workspaceName.trim() } : {}
   };
 }
+function parseFirstValueInitiative(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (!isNonEmptyString2(record.id) || !isNonEmptyString2(record.title) || !isNonEmptyString2(record.liveUrl) || !isNonEmptyString2(record.createdAt)) {
+    return void 0;
+  }
+  return {
+    createdAt: record.createdAt.trim(),
+    id: record.id.trim(),
+    liveUrl: record.liveUrl.trim(),
+    ...isNonEmptyString2(record.summary) ? { summary: record.summary.trim() } : {},
+    title: record.title.trim(),
+    ...isNonEmptyString2(record.workspaceId) ? { workspaceId: record.workspaceId.trim() } : {},
+    ...isNonEmptyString2(record.workspaceName) ? { workspaceName: record.workspaceName.trim() } : {}
+  };
+}
 function parseOnboardingTask(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return void 0;
@@ -1026,6 +1060,7 @@ function sanitizeWizardStateRecord(record) {
   const continuity = parseContinuityDefaults(record.continuity);
   const agentRoster = parseAgentRoster(record.agentRoster);
   const demoInitiative = parseDemoInitiative(record.demoInitiative);
+  const firstValueInitiative = parseFirstValueInitiative(record.firstValueInitiative);
   const onboardingTask = parseOnboardingTask(record.onboardingTask);
   const skillFiles = parseSkillFiles(record.skillFiles);
   return {
@@ -1035,6 +1070,7 @@ function sanitizeWizardStateRecord(record) {
     ...continuity ? { continuity } : {},
     ...agentRoster ? { agentRoster } : {},
     ...demoInitiative ? { demoInitiative } : {},
+    ...firstValueInitiative ? { firstValueInitiative } : {},
     ...onboardingTask ? { onboardingTask } : {},
     ...skillFiles ? { skillFiles } : {}
   };
@@ -1055,6 +1091,10 @@ function readWizardState(statePath = ORGX_WIZARD_STATE_PATH) {
   if (agentRoster !== void 0) state.agentRoster = agentRoster;
   const demoInitiative = parseDemoInitiative(parsed.demoInitiative);
   if (demoInitiative !== void 0) state.demoInitiative = demoInitiative;
+  const firstValueInitiative = parseFirstValueInitiative(parsed.firstValueInitiative);
+  if (firstValueInitiative !== void 0) {
+    state.firstValueInitiative = firstValueInitiative;
+  }
   const onboardingTask = parseOnboardingTask(parsed.onboardingTask);
   if (onboardingTask !== void 0) state.onboardingTask = onboardingTask;
   const skillFiles = parseSkillFiles(parsed.skillFiles);
@@ -2706,6 +2746,8 @@ var ONBOARDING_TASK_TITLE = "Complete OrgX onboarding";
 var ONBOARDING_TASK_SUMMARY = "Starter onboarding task created by @useorgx/wizard so the first workspace has a clear follow-up after setup.";
 var ONBOARDING_WORKSTREAM_TITLE = "OrgX onboarding";
 var ONBOARDING_WORKSTREAM_SUMMARY = "Starter onboarding workstream created by @useorgx/wizard so the first workspace has a home for setup follow-up tasks.";
+var FIRST_VALUE_INITIATIVE_TITLE = "Make OrgX useful on this machine";
+var FIRST_VALUE_INITIATIVE_SUMMARY = "First initiative created by @useorgx/wizard so setup ends with a live workspace, an onboarding workstream, and a clean handoff into the user's configured AI tools.";
 function parseResponseBody3(text2) {
   if (!text2) {
     return null;
@@ -2827,6 +2869,17 @@ function toOnboardingTaskRecord(task, workspace, options = {}) {
     workspaceName: workspace.name
   };
 }
+function toFirstValueInitiativeRecord(initiative, liveUrl, workspace) {
+  return {
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    id: initiative.id,
+    liveUrl,
+    ...initiative.summary ? { summary: initiative.summary } : {},
+    title: initiative.title,
+    workspaceId: workspace.id,
+    workspaceName: workspace.name
+  };
+}
 async function requireOrgxAuth2(options = {}) {
   const auth = await resolveOrgxAuth(options);
   if (!auth) {
@@ -2879,9 +2932,6 @@ async function updateEntity(type, id, body, parse2, options = {}) {
 }
 function buildLiveUrl(baseUrl, initiativeId) {
   const parsed = new URL(normalizeOrgxBaseUrl(baseUrl));
-  if (parsed.protocol === "https:" && parsed.hostname === "useorgx.com") {
-    parsed.hostname = "www.useorgx.com";
-  }
   parsed.pathname = `/live/${initiativeId}`;
   parsed.search = "";
   parsed.hash = "";
@@ -2992,6 +3042,43 @@ async function ensureFounderDemoInitiative(workspace, options = {}) {
     liveUrl
   };
 }
+async function ensureFirstValueInitiative(workspace, options = {}) {
+  const existingRecord = readWizardState(options.statePath)?.firstValueInitiative;
+  const matchingRecord = existingRecord?.workspaceId === workspace.id ? existingRecord : void 0;
+  const auth = await requireOrgxAuth2(options);
+  if (matchingRecord) {
+    return {
+      created: false,
+      initiative: {
+        id: matchingRecord.id,
+        title: matchingRecord.title,
+        ...matchingRecord.summary ? { summary: matchingRecord.summary } : {}
+      },
+      liveUrl: matchingRecord.liveUrl || buildLiveUrl(auth.baseUrl, matchingRecord.id)
+    };
+  }
+  const initiative = await createInitiative(
+    {
+      title: options.title?.trim() || FIRST_VALUE_INITIATIVE_TITLE,
+      summary: options.summary?.trim() || FIRST_VALUE_INITIATIVE_SUMMARY,
+      workspaceId: workspace.id
+    },
+    options
+  );
+  const liveUrl = buildLiveUrl(auth.baseUrl, initiative.id);
+  updateWizardState(
+    (current) => ({
+      ...current,
+      firstValueInitiative: toFirstValueInitiativeRecord(initiative, liveUrl, workspace)
+    }),
+    options.statePath
+  );
+  return {
+    created: true,
+    initiative,
+    liveUrl
+  };
+}
 async function ensureOnboardingTask(workspace, options = {}) {
   const existingRecord = readWizardState(options.statePath)?.onboardingTask;
   if (existingRecord?.workspaceId === workspace.id) {
@@ -4889,6 +4976,15 @@ function buildFounderDemoTelemetryProperties(result, base = {}) {
     base
   );
 }
+function buildFirstValueInitiativeTelemetryProperties(result, base = {}) {
+  return withBaseProperties(
+    {
+      created: result.created,
+      has_live_url: Boolean(result.liveUrl)
+    },
+    base
+  );
+}
 function buildDoctorTelemetryProperties(report, assessment, verification, base = {}) {
   const errorCount = assessment.issues.filter((issue) => issue.level === "error").length;
   const warningCount = assessment.issues.filter((issue) => issue.level === "warning").length;
@@ -5181,6 +5277,41 @@ function printWorkspaceSetupResult(result) {
     console.log(`  ${ICON.skip}  ${pc3.dim(result.message)}`);
   }
 }
+function printSetupScopeNote() {
+  console.log(pc3.dim("  setup updates your AI tools with:"));
+  console.log(`  ${ICON.skip}  ${pc3.dim("MCP configs for local and cloud OrgX access")}`);
+  console.log(`  ${ICON.skip}  ${pc3.dim("OrgX agent skills, rules, prompts, commands, and hooks")}`);
+  console.log(`  ${ICON.skip}  ${pc3.dim("companion plugins where your editor supports them")}`);
+}
+function printFirstValueHandoff(input) {
+  const cmd = getCmd();
+  console.log("");
+  console.log(pc3.bold("first OrgX handoff"));
+  console.log(
+    `  ${input.initiative.created ? pc3.green("created") : pc3.yellow("ready")} ${pc3.bold(input.initiative.initiative.title)}`
+  );
+  console.log(`  live: ${input.initiative.liveUrl}`);
+  console.log(
+    `  ${pc3.dim("ask your AI tool:")} ${pc3.cyan(
+      `Use OrgX to continue "${input.initiative.initiative.title}" in ${input.workspace.name}. Show the next action, then start with the onboarding task.`
+    )}`
+  );
+  console.log(`  ${pc3.dim("later:")} ${pc3.cyan(`${cmd} doctor`)} ${pc3.dim("checks tool wiring")}`);
+}
+function firstValueRecordToResult(record) {
+  if (!record) {
+    return null;
+  }
+  return {
+    created: false,
+    initiative: {
+      id: record.id,
+      title: record.title,
+      ...record.summary ? { summary: record.summary } : {}
+    },
+    liveUrl: record.liveUrl
+  };
+}
 function printFounderPresetResult(result) {
   printMutationResults(result.surfaceResults);
   console.log("");
@@ -5221,7 +5352,7 @@ async function textPrompt(input) {
 }
 async function multiselectPrompt(input) {
   const promptInput = {
-    message: `${input.message} ${pc3.dim("Space selects items; Enter continues.")}`,
+    message: `${input.message} ${pc3.dim("Space to select, Enter to continue. Defaults are preselected.")}`,
     options: input.options,
     ...input.initialValues ? { initialValues: input.initialValues } : {},
     ...input.required !== void 0 ? { required: input.required } : {}
@@ -5328,25 +5459,96 @@ async function maybeConfigureOptionalWorkspaceAddOns(input) {
     return "skipped";
   }
   const existingState = readWizardState();
-  const effectiveInitiativeId = input.initiativeId?.trim() || (existingState?.demoInitiative?.workspaceId === input.workspace.id ? existingState.demoInitiative.id : void 0);
-  const hasOnboardingTask = existingState?.onboardingTask?.workspaceId === input.workspace.id;
-  if (!hasOnboardingTask && effectiveInitiativeId) {
-    const onboardingChoice = await selectPrompt({
-      message: `Create a starter onboarding task for ${input.workspace.name}?`,
+  const providedInitiativeId = input.initiativeId?.trim();
+  const storedDemoInitiative = existingState?.demoInitiative?.workspaceId === input.workspace.id ? existingState.demoInitiative : void 0;
+  const storedFirstValueInitiative = existingState?.firstValueInitiative?.workspaceId === input.workspace.id ? existingState.firstValueInitiative : void 0;
+  let effectiveInitiativeId = providedInitiativeId || storedDemoInitiative?.id || storedFirstValueInitiative?.id;
+  let firstValueInitiative = providedInitiativeId || storedDemoInitiative ? null : firstValueRecordToResult(storedFirstValueInitiative);
+  if (!effectiveInitiativeId) {
+    const firstInitiativeChoice = await selectPrompt({
+      initialValue: "yes",
+      message: `Create your first OrgX initiative in ${input.workspace.name}?`,
       options: [
-        { value: "yes", label: "Create onboarding task", hint: "recommended" },
-        { value: "no", label: "Skip task creation" }
+        {
+          value: "yes",
+          label: "Create first initiative",
+          hint: "recommended; gives setup a live next step"
+        },
+        { value: "no", label: "Skip initiative creation" }
       ]
     });
-    if (clack.isCancel(onboardingChoice)) {
+    if (clack.isCancel(firstInitiativeChoice)) {
       clack.cancel("Setup cancelled.");
       return "cancelled";
     }
-    if (onboardingChoice === "yes") {
+    if (firstInitiativeChoice === "yes") {
+      const title = await textPrompt({
+        initialValue: FIRST_VALUE_INITIATIVE_TITLE,
+        message: "What should OrgX help you move forward first?",
+        validate: (value) => {
+          if (!value || value.trim().length === 0) {
+            return "Enter an initiative title.";
+          }
+          return void 0;
+        }
+      });
+      if (clack.isCancel(title)) {
+        clack.cancel("Setup cancelled.");
+        return "cancelled";
+      }
+      const spinner = createOrgxSpinner("Creating your first OrgX initiative and live handoff");
+      spinner.start();
+      try {
+        firstValueInitiative = await ensureFirstValueInitiative(input.workspace, {
+          title: String(title)
+        });
+        spinner.succeed(
+          firstValueInitiative.created ? "First OrgX initiative created" : "First OrgX initiative ready"
+        );
+        effectiveInitiativeId = firstValueInitiative.initiative.id;
+        await safeTrackWizardTelemetry(
+          "first_value_initiative_ready",
+          buildFirstValueInitiativeTelemetryProperties(
+            firstValueInitiative,
+            {
+              command: input.telemetry?.command ?? "setup",
+              ...input.telemetry?.preset ? { preset: input.telemetry.preset } : {}
+            }
+          )
+        );
+      } catch (error) {
+        spinner.fail("First OrgX initiative was not created");
+        const message = error instanceof Error ? error.message : String(error);
+        console.log(`  ${ICON.warn}  ${pc3.yellow("initiative")} ${pc3.dim(message)}`);
+      }
+    }
+  }
+  const hasOnboardingTask = existingState?.onboardingTask?.workspaceId === input.workspace.id;
+  if (!hasOnboardingTask && effectiveInitiativeId) {
+    let shouldCreateOnboardingTask = firstValueInitiative !== null;
+    if (!shouldCreateOnboardingTask) {
+      const onboardingChoice = await selectPrompt({
+        initialValue: "yes",
+        message: `Create a starter onboarding task for ${input.workspace.name}?`,
+        options: [
+          { value: "yes", label: "Create onboarding task", hint: "recommended" },
+          { value: "no", label: "Skip task creation" }
+        ]
+      });
+      if (clack.isCancel(onboardingChoice)) {
+        clack.cancel("Setup cancelled.");
+        return "cancelled";
+      }
+      shouldCreateOnboardingTask = onboardingChoice === "yes";
+    }
+    if (shouldCreateOnboardingTask) {
+      const spinner = createOrgxSpinner("Creating onboarding workstream and starter task");
+      spinner.start();
       try {
         const task = await ensureOnboardingTask(input.workspace, {
           initiativeId: effectiveInitiativeId
         });
+        spinner.succeed("Onboarding workstream and starter task ready");
         console.log(`  ${ICON.ok}  ${pc3.green("onboarding")} ${pc3.bold(task.title)}`);
         await safeTrackWizardTelemetry(
           "onboarding_task_created",
@@ -5363,11 +5565,18 @@ async function maybeConfigureOptionalWorkspaceAddOns(input) {
           )
         );
       } catch (error) {
+        spinner.fail("Onboarding task was not created");
         const message = error instanceof Error ? error.message : String(error);
         console.log(`  ${ICON.warn}  ${pc3.yellow("onboarding")} ${pc3.dim(message)}`);
       }
     }
   }
+  if (firstValueInitiative) {
+    printFirstValueHandoff({
+      initiative: firstValueInitiative,
+      workspace: input.workspace
+    });
+  }
   const refreshedState = readWizardState();
   const hasAgentRoster = refreshedState?.agentRoster?.workspaceId === input.workspace.id;
   if (!hasAgentRoster) {
@@ -5578,7 +5787,7 @@ function printDoctorReport(report, assessment) {
 async function main() {
   const program = new Command();
   program.name("orgx-wizard").description("Add OrgX MCP configs, skills/rules, and companion plugins to your local AI tools.").showHelpAfterError();
-  const pkgVersion = true ? "0.1.12" : void 0;
+  const pkgVersion = true ? "0.1.14" : void 0;
   program.version(pkgVersion ?? "unknown", "-V, --version");
   program.hook("preAction", () => {
     console.log(renderBanner(pkgVersion));
@@ -5590,6 +5799,8 @@ async function main() {
       interactive,
       preset: options.preset ?? "standard"
     });
+    printSetupScopeNote();
+    console.log("");
     if (options.preset) {
       if (options.preset !== "founder") {
         throw new Error(`Unknown setup preset '${options.preset}'. Supported presets: founder.`);