orizu 0.5.0 → 0.5.2

package/dist/github-setup.js

@@ -17,6 +17,16 @@ import { spawnSync } from 'child_process';
 import { mkdirSync } from 'fs';
 import { join } from 'path';
 import { authedFetch } from './http.js';
+import { assertWorkspaceDirUsable } from './workspace.js';
+/**
+ * Strip terminal control characters from server-supplied strings before they
+ * are printed (mirrors index.ts `sanitizeTerminalText`), so a hostile or
+ * mangled provisioning `warnings[]`/`defaultBranch` value can't inject escape
+ * sequences into the user's terminal.
+ */
+function sanitizeServerText(value) {
+    return String(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
+}
 const DEFAULT_POLL_INTERVAL_MS = 2000;
 const DEFAULT_POLL_TIMEOUT_MS = 180000;
 function defaultSleep(ms) {
@@ -54,18 +64,29 @@ export async function runGithubLink(teamSlug, io) {
     const { installUrl, state } = (await start.json());
     io.print('   Connect your team GitHub org by installing the Orizu GitHub App:');
     io.print(`     ${installUrl}`);
+    // Bug 2: personal accounts cannot host an auto-provisioned workbench.
+    io.print('   • Install into a GitHub ORGANIZATION, not a personal account. Personal');
+    io.print('     accounts are not supported for auto-provisioning; creating an org is free.');
+    // Bug 4: repo selection guidance — GitHub forces picking at least one repo.
+    io.print('   • On the "Repository access" step choose "Only select repositories" and pick');
+    io.print('     any one repo (GitHub requires at least one). Orizu adds the workbench repo');
+    io.print('     it creates automatically — do NOT choose "All repositories".');
     if (io.openUrl) {
         io.openUrl(installUrl);
-        io.print('   Opened the install page in your browser. Waiting for you to finish...');
+        io.print('   Opened the install page in your browser.');
     }
     else {
-        io.print('   Open the URL above, install the App, then return here. Waiting...');
+        io.print('   Open the URL above and install the App, then return here.');
     }
+    io.print(`   Waiting for you to finish installing in the browser… (Ctrl+C to abort; resume later with \`orizu github link --team ${teamSlug}\`).`);
     const now = io.now ?? (() => Date.now());
     const sleep = io.sleep ?? defaultSleep;
     const interval = io.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     const timeout = io.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
     const deadline = now() + timeout;
+    // Periodic heartbeat so a long install does not look hung; never echoes state.
+    const HEARTBEAT_MS = 15000;
+    let lastHeartbeat = now();
     for (;;) {
         const poll = await fetcher(`/api/cli/github/link?state=${encodeURIComponent(state)}`);
         if (poll.ok) {
@@ -77,11 +98,22 @@ export async function runGithubLink(teamSlug, io) {
             if (data.status === 'pending_confirmation') {
                 return await confirmLink(teamSlug, data.orgLogin ?? null, io, fetcher);
             }
+            // Distinguishable terminal errors (personal account / expired nonce): print
+            // the server's reason and exit non-zero instead of polling until timeout.
+            if (data.status === 'unsupported_account' || data.status === 'expired') {
+                throw new Error(data.error ??
+                    `GitHub link could not be completed. Re-run \`orizu github link --team ${teamSlug}\`.`);
+            }
+            // status 'pending' → keep waiting.
         }
         if (now() >= deadline) {
             throw new Error('Timed out waiting for the GitHub App install to complete. ' +
                 `Resume with \`orizu github link --team ${teamSlug}\` after finishing the install.`);
         }
+        if (now() - lastHeartbeat >= HEARTBEAT_MS) {
+            io.print('   …still waiting for the GitHub install to complete.');
+            lastHeartbeat = now();
+        }
         await sleep(interval);
     }
 }
@@ -156,6 +188,12 @@ export async function runHostedAttach(options, io) {
         const data = (await response.json());
         repoFullName = data.repo;
         provisioned = true;
+        if (data.rulesetApplied === true) {
+            io.print(`   Default-branch protection applied (ruleset "orizu-default-branch-protection"${data.defaultBranch ? ` on ${sanitizeServerText(data.defaultBranch)}` : ''}).`);
+        }
+        for (const warning of data.warnings ?? []) {
+            io.print(`   ⚠ ${sanitizeServerText(warning)}`);
+        }
     }
     const cleanUrl = `https://github.com/${repoFullName}.git`;
     io.print(`   Cloning ${repoFullName}...`);
@@ -221,6 +259,14 @@ export async function runInteractiveHostedSetup(input, io) {
     if (mode === 'local') {
         return { mode, attached: false, repoFullName: null };
     }
+    // The hosted paths (attach / provision-then-attach) clone the workbench repo
+    // into targetDir, and `git clone` refuses ANY non-empty directory. Fail fast
+    // here — before the provision call and the clone's git invocation, so no
+    // partial server/git state is created — with a friendly, actionable message
+    // (including the `--local` escape hatch). Only this real-clone path is gated;
+    // --local, --skip-login (not signed in), and a declined connect prompt never
+    // reach here, so they scaffold locally unblocked.
+    assertWorkspaceDirUsable(input.targetDir);
     const result = await runHostedAttach({ workspaceId: workspace.id, repoFullName, targetDir: input.targetDir }, { print: io.print, fetcher, git: io.git ?? defaultGitRunner, ensureOrizuDir: io.ensureOrizuDir });
     return { mode, attached: true, repoFullName: result.repoFullName };
 }

package/dist/index.js

@@ -2862,7 +2862,7 @@ async function setupCommand() {
     const skipConfirm = hasArg('--yes');
     const noInput = hasArg('--no-input') || hasArg('--non-interactive') || !isInteractiveTerminal();
     const workspaceArg = getOptionalArgValue('--workspace');
-    const workspaceRoot = workspaceArg ? resolve(expandHomePath(workspaceArg)) : process.cwd();
+    const workspaceRoot = workspaceArg ? resolve(expandHomePath(workspaceArg)) : process.cwd(); // non-empty-dir guard now lives next to the hosted clone in runInteractiveHostedSetup, so --skip-login / decline-connect / local scaffolds are never blocked
     const teamArg = getOptionalArgValue('--team');
     const projectArg = getOptionalArgValue('--project');
     const setupSkillHome = resolveSetupSkillHome();

package/dist/workspace.js

@@ -1,4 +1,4 @@
-import { existsSync, lstatSync, mkdirSync, readlinkSync, readdirSync, readFileSync, renameSync, symlinkSync, unlinkSync, writeFileSync, } from 'fs';
+import { existsSync, lstatSync, mkdirSync, readlinkSync, readdirSync, readFileSync, renameSync, statSync, symlinkSync, unlinkSync, writeFileSync, } from 'fs';
 import { dirname, join, relative, resolve } from 'path';
 export const WORKSPACE_DIR_NAME = '.orizu';
 export const WORKSPACE_SCHEMA_VERSION = 'orizu.workspace.v0';
@@ -82,6 +82,61 @@ export function getWorkspaceRoot(cwd) {
 export function workspaceExists(cwd) {
     return existsSync(join(getWorkspaceRoot(cwd), 'orizu.team.json'));
 }
+/**
+ * `orizu setup`'s hosted path clones the workbench repo into the resolved
+ * workspace root; `git clone` refuses to write into ANY non-empty directory —
+ * including one holding only macOS `.DS_Store` cruft — and fails late with a
+ * raw git error (ALI QA: founder ran `orizu setup` from an existing folder).
+ * Call this right before the hosted clone so the failure is immediate and
+ * actionable instead of surfacing mid-clone.
+ *
+ * A directory is usable only when it doesn't exist yet, is STRICTLY empty
+ * (`readdirSync(...).length === 0` — no `.DS_Store` allowance, since git itself
+ * grants none), or is already a recognized Orizu workspace for a re-run
+ * (`workspaceExists`, i.e. it has `orizu.team.json`) — the legitimate
+ * idempotent-setup case, which must proceed. Symlinks are followed (a symlink
+ * to an empty dir is fine); a file, an unreadable dir, and a non-empty dir each
+ * get a distinct, friendly message.
+ */
+export function assertWorkspaceDirUsable(root) {
+    const resolvedRoot = resolve(root);
+    if (!existsSync(resolvedRoot))
+        return;
+    if (workspaceExists(resolvedRoot))
+        return;
+    let stat;
+    try {
+        // statSync (not lstatSync) follows symlinks, so a symlink to an empty dir
+        // is treated as the empty dir it points at.
+        stat = statSync(resolvedRoot);
+    }
+    catch {
+        // Broken symlink / vanished between checks — nothing to clone over.
+        return;
+    }
+    if (!stat.isDirectory()) {
+        throw new Error(`The path ${resolvedRoot} is a file, but \`orizu setup\` needs a directory to clone your workbench repo into. `
+            + 'Choose an empty directory (or pass `--workspace <empty-path>`, or `--local` to scaffold a local-only workspace elsewhere), then re-run `orizu setup`.');
+    }
+    let entries;
+    try {
+        entries = readdirSync(resolvedRoot);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'EACCES' || code === 'EPERM') {
+            throw new Error(`The directory ${resolvedRoot} can't be read (permission denied). `
+                + 'Fix its permissions, or pass `--workspace <empty-path>` (or `--local`), then re-run `orizu setup`.');
+        }
+        throw error;
+    }
+    if (entries.length === 0)
+        return;
+    throw new Error(`The directory ${resolvedRoot} is not empty. \`orizu setup\` clones your workbench repo here and needs an empty directory. `
+        + 'Create and enter an empty sub-directory (for example: `mkdir orizu-workbench && cd orizu-workbench`), '
+        + 'pass `--workspace <empty-path>`, or pass `--local` to scaffold a local-only workspace in place, '
+        + 'then re-run `orizu setup`.');
+}
 function formatJson(value) {
     return `${JSON.stringify(value, null, 2)}\n`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orizu",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "private": false,
   "type": "module",
   "bin": {

package/src/github-setup.ts

@@ -19,9 +19,20 @@ import { mkdirSync } from 'fs'
 import { join } from 'path'
 
 import { authedFetch } from './http.js'
+import { assertWorkspaceDirUsable } from './workspace.js'
 
 export type SetupFetcher = (path: string, init?: RequestInit) => Promise<Response>
 
+/**
+ * Strip terminal control characters from server-supplied strings before they
+ * are printed (mirrors index.ts `sanitizeTerminalText`), so a hostile or
+ * mangled provisioning `warnings[]`/`defaultBranch` value can't inject escape
+ * sequences into the user's terminal.
+ */
+function sanitizeServerText(value: unknown): string {
+  return String(value).replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '')
+}
+
 export interface GithubLinkIo {
   print: (line: string) => void
   fetcher?: SetupFetcher
@@ -86,23 +97,40 @@ export async function runGithubLink(teamSlug: string, io: GithubLinkIo): Promise
 
   io.print('   Connect your team GitHub org by installing the Orizu GitHub App:')
   io.print(`     ${installUrl}`)
+  // Bug 2: personal accounts cannot host an auto-provisioned workbench.
+  io.print('   • Install into a GitHub ORGANIZATION, not a personal account. Personal')
+  io.print('     accounts are not supported for auto-provisioning; creating an org is free.')
+  // Bug 4: repo selection guidance — GitHub forces picking at least one repo.
+  io.print('   • On the "Repository access" step choose "Only select repositories" and pick')
+  io.print('     any one repo (GitHub requires at least one). Orizu adds the workbench repo')
+  io.print('     it creates automatically — do NOT choose "All repositories".')
   if (io.openUrl) {
     io.openUrl(installUrl)
-    io.print('   Opened the install page in your browser. Waiting for you to finish...')
+    io.print('   Opened the install page in your browser.')
   } else {
-    io.print('   Open the URL above, install the App, then return here. Waiting...')
+    io.print('   Open the URL above and install the App, then return here.')
   }
+  io.print(
+    `   Waiting for you to finish installing in the browser… (Ctrl+C to abort; resume later with \`orizu github link --team ${teamSlug}\`).`
+  )
 
   const now = io.now ?? (() => Date.now())
   const sleep = io.sleep ?? defaultSleep
   const interval = io.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS
   const timeout = io.pollTimeoutMs ?? DEFAULT_POLL_TIMEOUT_MS
   const deadline = now() + timeout
+  // Periodic heartbeat so a long install does not look hung; never echoes state.
+  const HEARTBEAT_MS = 15000
+  let lastHeartbeat = now()
 
   for (;;) {
     const poll = await fetcher(`/api/cli/github/link?state=${encodeURIComponent(state)}`)
     if (poll.ok) {
-      const data = (await poll.json()) as { status: string; orgLogin?: string | null }
+      const data = (await poll.json()) as {
+        status: string
+        orgLogin?: string | null
+        error?: string
+      }
       if (data.status === 'active') {
         io.print(`   GitHub org connected${data.orgLogin ? ` (${data.orgLogin})` : ''}.`)
         return { status: 'active', orgLogin: data.orgLogin ?? null, alreadyLinked: false }
@@ -110,6 +138,15 @@ export async function runGithubLink(teamSlug: string, io: GithubLinkIo): Promise
       if (data.status === 'pending_confirmation') {
         return await confirmLink(teamSlug, data.orgLogin ?? null, io, fetcher)
       }
+      // Distinguishable terminal errors (personal account / expired nonce): print
+      // the server's reason and exit non-zero instead of polling until timeout.
+      if (data.status === 'unsupported_account' || data.status === 'expired') {
+        throw new Error(
+          data.error ??
+            `GitHub link could not be completed. Re-run \`orizu github link --team ${teamSlug}\`.`
+        )
+      }
+      // status 'pending' → keep waiting.
     }
     if (now() >= deadline) {
       throw new Error(
@@ -117,6 +154,10 @@ export async function runGithubLink(teamSlug: string, io: GithubLinkIo): Promise
           `Resume with \`orizu github link --team ${teamSlug}\` after finishing the install.`
       )
     }
+    if (now() - lastHeartbeat >= HEARTBEAT_MS) {
+      io.print('   …still waiting for the GitHub install to complete.')
+      lastHeartbeat = now()
+    }
     await sleep(interval)
   }
 }
@@ -248,9 +289,25 @@ export async function runHostedAttach(
     if (!response.ok) {
       throw new Error(`Failed to provision workbench repo: ${await readError(response)}`)
     }
-    const data = (await response.json()) as { repo: string }
+    const data = (await response.json()) as {
+      repo: string
+      defaultBranch?: string
+      rulesetApplied?: boolean
+      warnings?: string[]
+    }
     repoFullName = data.repo
     provisioned = true
+
+    if (data.rulesetApplied === true) {
+      io.print(
+        `   Default-branch protection applied (ruleset "orizu-default-branch-protection"${
+          data.defaultBranch ? ` on ${sanitizeServerText(data.defaultBranch)}` : ''
+        }).`
+      )
+    }
+    for (const warning of data.warnings ?? []) {
+      io.print(`   ⚠ ${sanitizeServerText(warning)}`)
+    }
   }
 
   const cleanUrl = `https://github.com/${repoFullName}.git`
@@ -358,6 +415,15 @@ export async function runInteractiveHostedSetup(
     return { mode, attached: false, repoFullName: null }
   }
 
+  // The hosted paths (attach / provision-then-attach) clone the workbench repo
+  // into targetDir, and `git clone` refuses ANY non-empty directory. Fail fast
+  // here — before the provision call and the clone's git invocation, so no
+  // partial server/git state is created — with a friendly, actionable message
+  // (including the `--local` escape hatch). Only this real-clone path is gated;
+  // --local, --skip-login (not signed in), and a declined connect prompt never
+  // reach here, so they scaffold locally unblocked.
+  assertWorkspaceDirUsable(input.targetDir)
+
   const result = await runHostedAttach(
     { workspaceId: workspace.id, repoFullName, targetDir: input.targetDir },
     { print: io.print, fetcher, git: io.git ?? defaultGitRunner, ensureOrizuDir: io.ensureOrizuDir }

package/src/index.ts

@@ -3820,7 +3820,7 @@ async function setupCommand() {
   const skipConfirm = hasArg('--yes')
   const noInput = hasArg('--no-input') || hasArg('--non-interactive') || !isInteractiveTerminal()
   const workspaceArg = getOptionalArgValue('--workspace')
-  const workspaceRoot = workspaceArg ? resolve(expandHomePath(workspaceArg)) : process.cwd()
+  const workspaceRoot = workspaceArg ? resolve(expandHomePath(workspaceArg)) : process.cwd() // non-empty-dir guard now lives next to the hosted clone in runInteractiveHostedSetup, so --skip-login / decline-connect / local scaffolds are never blocked
   const teamArg = getOptionalArgValue('--team')
   const projectArg = getOptionalArgValue('--project')
   const setupSkillHome = resolveSetupSkillHome()

package/src/workspace.ts

@@ -6,6 +6,7 @@ import {
   readdirSync,
   readFileSync,
   renameSync,
+  statSync,
   symlinkSync,
   unlinkSync,
   writeFileSync,
@@ -185,6 +186,67 @@ export function workspaceExists(cwd?: string): boolean {
   return existsSync(join(getWorkspaceRoot(cwd), 'orizu.team.json'))
 }
 
+/**
+ * `orizu setup`'s hosted path clones the workbench repo into the resolved
+ * workspace root; `git clone` refuses to write into ANY non-empty directory —
+ * including one holding only macOS `.DS_Store` cruft — and fails late with a
+ * raw git error (ALI QA: founder ran `orizu setup` from an existing folder).
+ * Call this right before the hosted clone so the failure is immediate and
+ * actionable instead of surfacing mid-clone.
+ *
+ * A directory is usable only when it doesn't exist yet, is STRICTLY empty
+ * (`readdirSync(...).length === 0` — no `.DS_Store` allowance, since git itself
+ * grants none), or is already a recognized Orizu workspace for a re-run
+ * (`workspaceExists`, i.e. it has `orizu.team.json`) — the legitimate
+ * idempotent-setup case, which must proceed. Symlinks are followed (a symlink
+ * to an empty dir is fine); a file, an unreadable dir, and a non-empty dir each
+ * get a distinct, friendly message.
+ */
+export function assertWorkspaceDirUsable(root: string): void {
+  const resolvedRoot = resolve(root)
+  if (!existsSync(resolvedRoot)) return
+  if (workspaceExists(resolvedRoot)) return
+
+  let stat
+  try {
+    // statSync (not lstatSync) follows symlinks, so a symlink to an empty dir
+    // is treated as the empty dir it points at.
+    stat = statSync(resolvedRoot)
+  } catch {
+    // Broken symlink / vanished between checks — nothing to clone over.
+    return
+  }
+
+  if (!stat.isDirectory()) {
+    throw new Error(
+      `The path ${resolvedRoot} is a file, but \`orizu setup\` needs a directory to clone your workbench repo into. `
+      + 'Choose an empty directory (or pass `--workspace <empty-path>`, or `--local` to scaffold a local-only workspace elsewhere), then re-run `orizu setup`.'
+    )
+  }
+
+  let entries: string[]
+  try {
+    entries = readdirSync(resolvedRoot)
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code
+    if (code === 'EACCES' || code === 'EPERM') {
+      throw new Error(
+        `The directory ${resolvedRoot} can't be read (permission denied). `
+        + 'Fix its permissions, or pass `--workspace <empty-path>` (or `--local`), then re-run `orizu setup`.'
+      )
+    }
+    throw error
+  }
+  if (entries.length === 0) return
+
+  throw new Error(
+    `The directory ${resolvedRoot} is not empty. \`orizu setup\` clones your workbench repo here and needs an empty directory. `
+    + 'Create and enter an empty sub-directory (for example: `mkdir orizu-workbench && cd orizu-workbench`), '
+    + 'pass `--workspace <empty-path>`, or pass `--local` to scaffold a local-only workspace in place, '
+    + 'then re-run `orizu setup`.'
+  )
+}
+
 function formatJson(value: Record<string, unknown>): string {
   return `${JSON.stringify(value, null, 2)}\n`
 }