orizu 0.5.1 → 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) {
@@ -178,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}...`);
@@ -243,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.1",
+  "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
@@ -278,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`
@@ -388,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`
 }