lecodes-cli 0.20.2 → 2.0.0

package/src/commands/link.ts

@@ -1,16 +1,17 @@
 import { existsSync } from "node:fs"
 import { basename, join, resolve } from "node:path"
-import { createProject, getCommits, getProject, type Project, type ProjectAsset } from "../api"
-import { loadConfig, requireApiUrl, requireToken } from "../config"
-import { ensureGitignore, writeDefaultIgnore } from "../ignore"
-import { scanProject } from "../localFiles"
-import { findProjectRoot, LECODES_DIR, writeManifest, type FileKind, type ManifestFile, type Manifest } from "../manifest"
-import { buildPaths } from "../project"
-import { computeServerDiff } from "../serverDiff"
-import { materializeTypes, writeTsconfig } from "../types"
-import { CliError, c, confirm, flagBool, flagStr, info, log, note, sha256, success, warn, type Args } from "../util"
+import { CliError, bool, c, confirm, defineCommand, info, log, note, str, success, warn } from "../cli"
+import { createProject, getCommits, getProject, type Project, type ProjectAsset } from "../platform/api"
+import { computeServerDiff } from "../platform/serverDiff"
+import { ensureGitignore, writeDefaultIgnore } from "../project/ignore"
+import { scanProject } from "../project/localFiles"
+import { findProjectRoot, LECODES_DIR, writeManifest, type FileKind, type Manifest, type ManifestFile } from "../project/manifest"
+import { buildPaths } from "../project/materialize"
+import { sha256 } from "../project/paths"
+import { materializeTypes, writeTsconfig } from "../project/types"
 import { parseUuid } from "./clone"
-import { push } from "./push"
+import { pushFlags, runPush } from "./push"
+import { session } from "./shared"
 
 /*
  * `lecodes link [dir]` — connect an existing local folder (typically one made by `lecodes init`) to
@@ -38,110 +39,102 @@ const manifestFromServer = (project: Project): Record<string, ManifestFile> => {
   const files: Record<string, ManifestFile> = {}
   for (const asset of project.assets) {
     if (asset.type === "folder") continue
-    files[pathById.get(asset.id)!] = {
-      id: asset.id,
-      type: kindOf(asset.type),
-      sha: asset.type === "file" ? "" : sha256(asset.text ?? ""),
-    }
+    files[pathById.get(asset.id)!] = { id: asset.id, type: kindOf(asset.type), sha: asset.type === "file" ? "" : sha256(asset.text ?? "") }
   }
   return files
 }
 
 /** Show what a push from this folder would do to the project's server tree, and get a yes. */
-const confirmAdoption = async (root: string, project: Project, files: Record<string, ManifestFile>, args: Args): Promise<boolean> => {
+const confirmAdoption = async (root: string, project: Project, files: Record<string, ManifestFile>, skipAsk: boolean): Promise<boolean> => {
   const count = Object.keys(files).length
-  if (count === 0) {
-    info(c.dim(`Project ${c.bold(project.name)} is empty on the server — nothing to overwrite.`))
-    return true
-  }
+  if (count === 0) { info(c.dim(`Project ${c.bold(project.name)} is empty on the server — nothing to overwrite.`)); return true }
 
   const scan = scanProject(root, { files } as Manifest)
   const diff = computeServerDiff(project, scan)
-  if (diff.length === 0) {
-    info(c.dim(`Project ${c.bold(project.name)} (${count} file(s)) already matches this folder.`))
-    return true
-  }
+  if (diff.length === 0) { info(c.dim(`Project ${c.bold(project.name)} (${count} file(s)) already matches this folder.`)); return true }
 
   warn(`${c.bold(project.name)} already has ${count} file(s). Your next push would change the server:`)
   const label: Record<string, string> = { added: c.green("  create  "), removed: c.red("  delete  "), modified: c.yellow("  update  ") }
   for (const e of diff) log(label[e.status] + e.path + (e.binary ? c.dim(" (binary)") : ""))
   log("")
   note("`lecodes pull` after linking takes the server's version instead.")
-
-  if (flagBool(args, "y", "yes") || flagBool(args, "force") || !process.stdin.isTTY) return true
+  if (skipAsk || !process.stdin.isTTY) return true
   return confirm("Link this folder to that project?", false)
 }
 
-export const link = async (args: Args) => {
-  const config = loadConfig()
-  const apiUrl = requireApiUrl(config)
-  const token = requireToken(config)
-
-  const dirArg = args._[0]
-  const root = dirArg ? resolve(dirArg) : process.cwd()
-  if (!existsSync(root)) throw new CliError(`No such directory: ${root}`)
-
-  // Already linked? Re-linking silently would orphan the old project's history.
-  if (existsSync(join(root, LECODES_DIR, "manifest.json")) && !flagBool(args, "force")) {
-    throw new CliError("This folder is already linked (.lecodes/manifest.json exists) — use `lecodes push`, or `lecodes link --force` to re-link it to another project.")
-  }
-  // …or sitting inside a linked project, where a nested manifest would shadow the real root.
-  let enclosing: string | null = null
-  try { enclosing = findProjectRoot(root) } catch { /* not inside a project — the normal case */ }
-  if (enclosing && enclosing !== root) {
-    throw new CliError(`This folder is inside the linked project at ${enclosing} — push from there instead.`)
-  }
-
-  const projectRef = flagStr(args, "project")
-  let uuid: string
-  let name: string
-  let files: Record<string, ManifestFile>
-
-  if (projectRef) {
-    uuid = parseUuid(projectRef)
-    const project = await getProject(apiUrl, token, uuid)
-    if (project.role === "viewer") {
-      throw new CliError(`You have view-only access to ${project.name} — linking would give you a checkout you can't push.`)
+export default defineCommand({
+  name: "link",
+  summary: "Connect an existing local folder to the platform (the reverse of clone)",
+  usage: "[dir]",
+  description: "Creates a project on the server, writes .lecodes/manifest.json and refreshes the types; nothing is uploaded until you push, so `status` shows what would go up first. `--project` adopts an EXISTING project instead: the manifest is built from its server tree and the command prints exactly what your next push would create / update / delete there before linking.",
+  flags: {
+    name: str("project name (default: the folder name)", { value: "<s>" }),
+    team: str("create it inside a team", { value: "<uuid>" }),
+    project: str("adopt an existing project instead of creating one", { value: "<uuid|url>" }),
+    push: bool("push right after linking (--publish to deploy it live in the same step)"),
+    "no-types": bool("skip the .d.ts / tsconfig refresh"),
+    ...pushFlags,
+  },
+  examples: ["lecodes link", "lecodes link --project <uuid> && lecodes status", 'lecodes link --push -m "initial"'],
+  run: async ({ args, flags }) => {
+    const { apiUrl, token } = session()
+    const dirArg = args[0]
+    const root = dirArg ? resolve(dirArg) : process.cwd()
+    if (!existsSync(root)) throw new CliError(`No such directory: ${root}`)
+
+    // Already linked? Re-linking silently would orphan the old project's history.
+    if (existsSync(join(root, LECODES_DIR, "manifest.json")) && !flags.force) {
+      throw new CliError("This folder is already linked (.lecodes/manifest.json exists) — use `lecodes push`, or `lecodes link --force` to re-link it to another project.")
+    }
+    // …or sitting inside a linked project, where a nested manifest would shadow the real root.
+    let enclosing: string | null = null
+    try { enclosing = findProjectRoot(root) } catch { /* not inside a project — the normal case */ }
+    if (enclosing && enclosing !== root) throw new CliError(`This folder is inside the linked project at ${enclosing} — push from there instead.`)
+
+    let uuid: string
+    let name: string
+    let files: Record<string, ManifestFile>
+    if (flags.project) {
+      uuid = parseUuid(flags.project)
+      const project = await getProject(apiUrl, token, uuid)
+      if (project.role === "viewer") throw new CliError(`You have view-only access to ${project.name} — linking would give you a checkout you can't push.`)
+      files = manifestFromServer(project)
+      if (!(await confirmAdoption(root, project, files, flags.yes || flags.force))) { info(c.dim("Aborted — nothing was linked.")); return }
+      name = project.name
+    } else {
+      name = flags.name ?? basename(root)
+      info(c.dim(`Creating project ${c.bold(name)}…`))
+      uuid = (await createProject(apiUrl, token, name, flags.team)).uuid
+      files = {}                                    // fresh project: the whole folder is a pending add
     }
-    files = manifestFromServer(project)
-    if (!(await confirmAdoption(root, project, files, args))) { info(c.dim("Aborted — nothing was linked.")); return }
-    name = project.name
-  } else {
-    name = flagStr(args, "name") ?? basename(root)
-    info(c.dim(`Creating project ${c.bold(name)}…`))
-    uuid = (await createProject(apiUrl, token, name, flagStr(args, "team"))).uuid
-    files = {}                                    // fresh project: the whole folder is a pending add
-  }
 
-  const commits = await getCommits(apiUrl, token, uuid)
-  writeManifest(root, { uuid, apiUrl, name, baseHeadId: commits.headId, files })
-  log(`${c.green("linked")}    ${c.bold(name)} ${c.dim(uuid)}`)
+    const commits = await getCommits(apiUrl, token, uuid)
+    writeManifest(root, { uuid, apiUrl, name, baseHeadId: commits.headId, files })
+    log(`${c.green("linked")}    ${c.bold(name)} ${c.dim(uuid)}`)
 
-  // Now that there IS a server, take its type surface — it matches the runtime the project will
-  // actually run on, unlike the CLI-bundled copy `lecodes init` wrote.
-  if (!flagBool(args, "no-types")) {
-    await materializeTypes(root, apiUrl)
-    writeTsconfig(root)
-    log(`${c.green("written")}   ${LECODES_DIR}/types/ + tsconfig.json  ${c.dim("(from the server)")}`)
-  }
-  writeDefaultIgnore(root)
-  if (ensureGitignore(root)) log(`${c.green("written")}   .gitignore  ${c.dim("(.lecodes/ is per-checkout state)")}`)
+    // Now that there IS a server, take its type surface — it matches the runtime the project will
+    // actually run on, unlike the CLI-bundled copy `lecodes init` wrote.
+    if (!flags["no-types"]) {
+      await materializeTypes(root, apiUrl)
+      writeTsconfig(root)
+      log(`${c.green("written")}   ${LECODES_DIR}/types/ + tsconfig.json  ${c.dim("(from the server)")}`)
+    }
+    writeDefaultIgnore(root)
+    if (ensureGitignore(root)) log(`${c.green("written")}   .gitignore  ${c.dim("(.lecodes/ is per-checkout state)")}`)
+
+    if (flags.push) {
+      log("")
+      if (root !== process.cwd()) process.chdir(root)   // push works from the current project root
+      await runPush(flags)
+      return
+    }
 
-  if (flagBool(args, "push")) {
+    const pending = scanProject(root, { files } as Manifest).files.filter((f) => { const known = files[f.path]; return !known || known.sha !== f.sha }).length
     log("")
-    if (root !== process.cwd()) process.chdir(root)   // push works from the current project root
-    await push(args)
-    return
-  }
-
-  const pending = scanProject(root, { files } as Manifest).files.filter((f) => {
-    const known = files[f.path]
-    return !known || known.sha !== f.sha
-  }).length
-  log("")
-  success(`Connected to ${c.bold(name)}.`)
-  const cd = dirArg ? `cd ${dirArg} && ` : ""
-  log(`  ${c.bold(cd + "lecodes status")}             ${pending} file(s) would go up`)
-  log(`  ${c.bold(cd + 'lecodes push -m "initial"')}  push them as the first checkpoint`)
-  log(`  ${c.dim("(add --publish to deploy it live in the same step)")}`)
-}
+    success(`Connected to ${c.bold(name)}.`)
+    const cd = dirArg ? `cd ${dirArg} && ` : ""
+    log(`  ${c.bold(cd + "lecodes status")}             ${pending} file(s) would go up`)
+    log(`  ${c.bold(cd + 'lecodes push -m "initial"')}  push them as the first checkpoint`)
+    log(`  ${c.dim("(add --publish to deploy it live in the same step)")}`)
+  },
+})

package/src/commands/login.ts

@@ -1,24 +1,26 @@
-import { getAccount } from "../api"
-import { DEFAULT_API, loadConfig, normalizeApiUrl, saveConfig } from "../config"
-import { browserLogin } from "../browserAuth"
-import { flagStr, success, c, type Args } from "../util"
+import { c, defineCommand, str, success } from "../cli"
+import { getAccount } from "../platform/api"
+import { browserLogin } from "../platform/browserAuth"
+import { DEFAULT_API, loadConfig, normalizeApiUrl, saveConfig } from "../platform/config"
 
-/*
- * `lecodes login` — authorize this machine and store a personal access token in ~/.lecodes.
- *   - default: open the browser, sign in / authorize on le.codes, capture the token.
- *   - `--token <pat>`: store a token created in the web UI (headless / CI).
- *   - `--api <url>`: API origin (defaults to https://le.codes).
- *   - `--web <url>`: app origin for the browser flow (defaults to the API origin).
- */
-export const login = async (args: Args) => {
-  const config = loadConfig()
-  const apiUrl = normalizeApiUrl(flagStr(args, "api") ?? config.apiUrl ?? DEFAULT_API)
-  const webBase = normalizeApiUrl(flagStr(args, "web") ?? apiUrl)
-
-  const token = flagStr(args, "token") ?? await browserLogin(webBase)
-
-  // Verify the token works against the API before persisting it.
-  const account = await getAccount(apiUrl, token)
-  saveConfig({ apiUrl, token })
-  success(`Logged in as ${c.bold(account.email)} on ${apiUrl}`)
-}
+/* `lecodes login` — authorize this machine; the token lands in ~/.lecodes/config.json. */
+export default defineCommand({
+  name: "login",
+  summary: "Authorize in the browser and store an access token",
+  description: "Opens the browser to sign in / authorize on le.codes and captures the token. `--token` stores a token created in the web UI instead (headless / CI). LECODES_API / LECODES_TOKEN in the environment override the stored values.",
+  flags: {
+    token: str("store a personal access token from the web UI instead of the browser flow", { value: "<pat>" }),
+    api: str(`API origin (default: the stored one, else ${DEFAULT_API})`, { value: "<url>" }),
+    web: str("app origin for the browser flow (default: the API origin)", { value: "<url>" }),
+  },
+  run: async ({ flags }) => {
+    const config = loadConfig()
+    const apiUrl = normalizeApiUrl(flags.api ?? config.apiUrl ?? DEFAULT_API)
+    const webBase = normalizeApiUrl(flags.web ?? apiUrl)
+    const token = flags.token ?? await browserLogin(webBase)
+    // Verify the token works against the API before persisting it.
+    const account = await getAccount(apiUrl, token)
+    saveConfig({ apiUrl, token })
+    success(`Logged in as ${c.bold(account.email)} on ${apiUrl}`)
+  },
+})