crewcode-plugin-cli 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 OnPoint Tools
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,39 @@
+# crewcode-plugin-cli
+
+Command-line tool for scaffolding, developing, and packaging [CrewCode](https://github.com/CjLogic/CrewCode) plugins. Exposes the `crewcode` binary.
+
+## Install
+
+```bash
+npm install -g crewcode-plugin-cli
+```
+
+Or run without installing:
+
+```bash
+npx crewcode-plugin-cli plugin list
+```
+
+## Quick start
+
+```bash
+crewcode plugin list                                    # show all templates
+crewcode plugin create my-plugin --template static-panel
+crewcode plugin dev ./my-plugin                         # live-install for development
+crewcode plugin package ./my-plugin                     # build a distributable archive
+```
+
+## Commands
+
+- `crewcode plugin list` — list every bundled template with its aliases and description.
+- `crewcode plugin create <id>` — scaffold a local plugin from a bundled template. Flags: `--template`, `--out`, `--name`, `--force`.
+- `crewcode plugin dev [pluginDir]` — validate and install a plugin into `~/.crewcode/plugins` (override with `CREWCODE_PLUGINS_DIR`) as a symlink/junction by default. Flags: `--copy`, `--build`, `--watch`.
+- `crewcode plugin package [pluginDir]` — validate, optionally build, and write a `.crewcode-plugin.tgz` plus a SHA-256 summary JSON. Flag: `--no-build`.
+
+## Templates
+
+Run `crewcode plugin list` for the current set with descriptions. Each has short aliases, e.g. `--template panel`, `--template react`, `--template mcp`.
+
+## License
+
+Apache-2.0.

package/bin/crewcode.mjs

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+import { createHash } from 'crypto'
+import { fileURLToPath, pathToFileURL } from 'url'
+import { createReadStream, createWriteStream } from 'fs'
+import {
+  cpSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from 'fs'
+import { tmpdir, homedir } from 'os'
+import { dirname, join, relative, resolve, sep } from 'path'
+import { spawnSync } from 'child_process'
+import { createGzip } from 'zlib'
+
+const API_VERSION = '0.1'
+const MANIFEST = 'crewcode.plugin.json'
+const TEMPLATE_ALIASES = new Map([
+  ['static', 'static-panel-template'],
+  ['static-panel', 'static-panel-template'],
+  ['panel', 'static-panel-template'],
+  ['typescript', 'typescript-panel-template'],
+  ['typescript-panel', 'typescript-panel-template'],
+  ['react', 'typescript-panel-template'],
+  ['ts-react', 'typescript-panel-template'],
+  ['mock-agent', 'mock-agent-provider'],
+  ['http-agent', 'company-agent-http-adapter'],
+  ['openai-agent', 'openai-compatible-provider'],
+  ['exec-agent', 'github-copilot-cli-provider'],
+  ['mcp', 'mcp-server-template'],
+  ['browser-action', 'browser-docs-grabber'],
+  ['git-lens', 'git-risk-lens'],
+  ['graph', 'codebase-graph-lite'],
+  ['handoff', 'handoff-pack'],
+  ['mission', 'mission-ci-widget'],
+  ['mission-widget', 'mission-ci-widget'],
+  ['radar', 'repo-radar'],
+  ['watchdog', 'terminal-watchdog-lite'],
+  ['terminal-watcher', 'terminal-watchdog-lite'],
+])
+const SKIP_DIRS = new Set(['.git', 'node_modules', '.cache', '.turbo', 'dist'])
+const SKIP_FILES = new Set(['.DS_Store'])
+const VALID_PERMISSIONS = new Set([
+  'workspace:read', 'workspace:write', 'git:read', 'git:write', 'terminal:spawn', 'terminal:read',
+  'agent:prompt', 'agent:provider', 'browser:read', 'mcp:server', 'network:fetch', 'secrets:read',
+])
+const CONTRIBUTION_KEYS = [
+  'commands', 'tabs', 'sidebarPanels', 'statusItems', 'editorActions', 'chatActions', 'chatHeaderItems',
+  'mcpServers', 'agentProviders', 'gitLenses', 'missionWidgets', 'terminalWatchers', 'browserActions',
+]
+
+function packageRoot() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), '..')
+}
+
+// Derived from disk, not hardcoded: the old static list had drifted and hid 5
+// of the 14 shipped templates.
+function listTemplates() {
+  const root = join(packageRoot(), 'templates', 'plugins')
+  if (!existsSync(root)) return []
+  const aliasesFor = new Map()
+  for (const [alias, target] of TEMPLATE_ALIASES) {
+    if (!aliasesFor.has(target)) aliasesFor.set(target, [])
+    aliasesFor.get(target).push(alias)
+  }
+  const out = []
+  for (const name of readdirSync(root).sort()) {
+    const manifestPath = join(root, name, MANIFEST)
+    if (!existsSync(manifestPath)) continue
+    let description = ''
+    try { description = String(readJson(manifestPath).description || '') } catch { /* unreadable */ }
+    out.push({ name, aliases: aliasesFor.get(name) || [], description })
+  }
+  return out
+}
+
+function formatTemplates() {
+  return listTemplates().map(t => {
+    const alias = t.aliases.length ? `  (${t.aliases.join(', ')})` : ''
+    const desc = t.description ? `\n      ${t.description}` : ''
+    return `  ${t.name}${alias}${desc}`
+  }).join('\n')
+}
+
+function usage() {
+  return `crewcode plugin <command> [options]
+
+Commands:
+  create <id> [--template static-panel] [--out <dir>] [--name <name>] [--force]
+  dev [pluginDir] [--copy] [--watch] [--build]
+  package [pluginDir] [--out <dir>] [--no-build]
+  list
+
+Templates:
+${formatTemplates()}
+`
+}
+
+export function listCommand() {
+  const templates = listTemplates()
+  console.log(`${templates.length} templates available:\n`)
+  console.log(formatTemplates())
+  return { ok: true, templates: templates.map(t => t.name) }
+}
+
+function parseArgs(argv) {
+  const args = []
+  const flags = new Map()
+  for (let i = 0; i < argv.length; i += 1) {
+    const item = argv[i]
+    if (!item.startsWith('--')) { args.push(item); continue }
+    const raw = item.slice(2)
+    if (raw.startsWith('no-')) { flags.set(raw.slice(3), false); continue }
+    const eq = raw.indexOf('=')
+    if (eq !== -1) { flags.set(raw.slice(0, eq), raw.slice(eq + 1)); continue }
+    const next = argv[i + 1]
+    if (next && !next.startsWith('--')) { flags.set(raw, next); i += 1 }
+    else flags.set(raw, true)
+  }
+  return { args, flags }
+}
+
+function pluginHome() {
+  return process.env.CREWCODE_PLUGINS_DIR || join(homedir(), '.crewcode', 'plugins')
+}
+
+function titleFromId(id) {
+  return id.split(/[-_.]+/).filter(Boolean).map(part => part[0]?.toUpperCase() + part.slice(1)).join(' ')
+}
+
+function validatePluginId(id) {
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(id)) throw new Error(`invalid plugin id "${id}"`)
+}
+
+function templateDir(name) {
+  const resolvedName = TEMPLATE_ALIASES.get(name) || name
+  const dir = join(packageRoot(), 'templates', 'plugins', resolvedName)
+  if (!existsSync(join(dir, MANIFEST))) throw new Error(`unknown template "${name}"`)
+  return dir
+}
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, 'utf8'))
+}
+
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+}
+
+function safeInside(root, target) {
+  const rel = relative(root, target)
+  return rel === '' || (!!rel && !rel.startsWith('..') && !rel.includes(`..${sep}`))
+}
+
+function validateManifest(pluginDir) {
+  const manifestPath = join(pluginDir, MANIFEST)
+  if (!existsSync(manifestPath)) throw new Error(`missing ${MANIFEST}`)
+  const manifest = readJson(manifestPath)
+  validatePluginId(String(manifest.id || ''))
+  if (!manifest.name || typeof manifest.name !== 'string') throw new Error('manifest.name must be a non-empty string')
+  if (!manifest.version || typeof manifest.version !== 'string') throw new Error('manifest.version must be a non-empty string')
+  const apiVersion = manifest.crewcode?.apiVersion || API_VERSION
+  if (apiVersion !== API_VERSION) throw new Error(`unsupported crewcode.apiVersion "${apiVersion}"; supported: ${API_VERSION}`)
+  for (const permission of manifest.permissions || []) {
+    if (!VALID_PERMISSIONS.has(permission)) throw new Error(`unknown permission "${permission}"`)
+  }
+  const contributes = manifest.contributes || {}
+  for (const key of Object.keys(contributes)) {
+    if (!CONTRIBUTION_KEYS.includes(key)) throw new Error(`unknown contributes.${key}`)
+  }
+  for (const key of ['tabs', 'sidebarPanels']) {
+    for (const panel of contributes[key] || []) {
+      if (!panel.entry || typeof panel.entry !== 'string') throw new Error(`contributes.${key} entry required`)
+      if (/^(?:[a-zA-Z][a-zA-Z0-9+.-]*:|[\\/])/.test(panel.entry)) throw new Error(`contributes.${key} entry must be relative`)
+      const entryPath = resolve(pluginDir, panel.entry)
+      if (!safeInside(pluginDir, entryPath)) throw new Error(`contributes.${key} entry escapes plugin folder`)
+      if (!existsSync(entryPath)) throw new Error(`panel entry missing: ${panel.entry}`)
+    }
+  }
+  return manifest
+}
+
+function copyTemplate(src, dest, force) {
+  if (existsSync(dest)) {
+    if (!force) throw new Error(`destination exists: ${dest}`)
+    rmSync(dest, { recursive: true, force: true })
+  }
+  mkdirSync(dirname(dest), { recursive: true })
+  cpSync(src, dest, { recursive: true, filter: source => !source.includes(`${sep}node_modules${sep}`) })
+}
+
+function rewriteCreatedProject(dest, id, name) {
+  const manifestPath = join(dest, MANIFEST)
+  const manifest = readJson(manifestPath)
+  manifest.$schema = 'https://crewcode.cortex-ai.icu/schemas/crewcode.plugin.schema.json'
+  manifest.id = id
+  manifest.name = name
+  if (manifest.contributes?.tabs) {
+    for (const tab of manifest.contributes.tabs) if (typeof tab.title === 'string') tab.title = name
+  }
+  if (manifest.contributes?.sidebarPanels) {
+    for (const panel of manifest.contributes.sidebarPanels) if (typeof panel.title === 'string') panel.title = name
+  }
+  writeJson(manifestPath, manifest)
+
+  const packagePath = join(dest, 'package.json')
+  if (existsSync(packagePath)) {
+    const pkg = readJson(packagePath)
+    pkg.name = id
+    writeJson(packagePath, pkg)
+  }
+}
+
+export function createPlugin(argv) {
+  const { args, flags } = parseArgs(argv)
+  const id = args[0]
+  if (!id) throw new Error('plugin id required')
+  validatePluginId(id)
+  const name = String(flags.get('name') || titleFromId(id))
+  const template = String(flags.get('template') || 'static-panel')
+  const outRoot = resolve(String(flags.get('out') || process.cwd()))
+  const dest = resolve(outRoot, id)
+  copyTemplate(templateDir(template), dest, flags.get('force') === true)
+  rewriteCreatedProject(dest, id, name)
+  validateManifest(dest)
+  return { ok: true, path: dest, id, name, template }
+}
+
+function installPlugin(pluginDir, copyMode) {
+  const manifest = validateManifest(pluginDir)
+  const root = pluginHome()
+  const dest = join(root, manifest.id)
+  mkdirSync(root, { recursive: true })
+  rmSync(dest, { recursive: true, force: true })
+  if (copyMode) {
+    cpSync(pluginDir, dest, { recursive: true, filter: source => !source.includes(`${sep}node_modules${sep}`) })
+    return { manifest, dest, mode: 'copy' }
+  }
+  const type = process.platform === 'win32' ? 'junction' : 'dir'
+  symlinkSync(resolve(pluginDir), dest, type)
+  return { manifest, dest, mode: 'link' }
+}
+
+function runPackageScript(pluginDir, script, inherit = true) {
+  if (!existsSync(join(pluginDir, 'package.json'))) return { ran: false, status: 0 }
+  const pkg = readJson(join(pluginDir, 'package.json'))
+  if (!pkg.scripts?.[script]) return { ran: false, status: 0 }
+  const result = spawnSync('npm', ['run', script], { cwd: pluginDir, stdio: inherit ? 'inherit' : 'pipe', shell: process.platform === 'win32' })
+  if (result.status !== 0) throw new Error(`npm run ${script} failed`)
+  return { ran: true, status: result.status }
+}
+
+export function devPlugin(argv) {
+  const { args, flags } = parseArgs(argv)
+  const pluginDir = resolve(args[0] || process.cwd())
+  if (flags.get('build') === true) runPackageScript(pluginDir, 'build')
+  const installed = installPlugin(pluginDir, flags.get('copy') === true)
+  if (flags.get('watch') === true) {
+    runPackageScript(pluginDir, 'dev')
+  }
+  return { ok: true, pluginId: installed.manifest.id, path: installed.dest, mode: installed.mode }
+}
+
+function collectPackageFiles(root) {
+  const files = []
+  function walk(dir) {
+    for (const name of readdirSync(dir)) {
+      if (SKIP_FILES.has(name)) continue
+      const abs = join(dir, name)
+      const rel = relative(root, abs).replace(/\\/g, '/')
+      const st = lstatSync(abs)
+      if (st.isDirectory()) {
+        if (SKIP_DIRS.has(name)) continue
+        walk(abs)
+      } else if (st.isFile()) {
+        files.push({ abs, rel, mode: st.mode & 0o777, size: st.size })
+      }
+    }
+  }
+  walk(root)
+  files.sort((a, b) => a.rel.localeCompare(b.rel))
+  return files
+}
+
+function tarHeader(name, size, mode, mtime = 0) {
+  const buf = Buffer.alloc(512, 0)
+  const write = (text, offset, length) => buf.write(String(text).slice(0, length), offset, length, 'utf8')
+  write(name, 0, 100)
+  write(mode.toString(8).padStart(7, '0') + '\0', 100, 8)
+  write('0000000\0', 108, 8)
+  write('0000000\0', 116, 8)
+  write(size.toString(8).padStart(11, '0') + '\0', 124, 12)
+  write(Math.floor(mtime).toString(8).padStart(11, '0') + '\0', 136, 12)
+  buf.fill(0x20, 148, 156)
+  write('0', 156, 1)
+  write('ustar\0', 257, 6)
+  write('00', 263, 2)
+  let sum = 0
+  for (const byte of buf) sum += byte
+  write(sum.toString(8).padStart(6, '0') + '\0 ', 148, 8)
+  return buf
+}
+
+function writeTarGz(root, files, outFile) {
+  const tempTar = join(mkdtempSync(join(tmpdir(), 'crewcode-plugin-package-')), 'plugin.tar')
+  const out = createWriteStream(tempTar)
+  for (const file of files) {
+    out.write(tarHeader(`package/${file.rel}`, file.size, file.mode))
+    out.write(readFileSync(file.abs))
+    const pad = (512 - (file.size % 512)) % 512
+    if (pad) out.write(Buffer.alloc(pad, 0))
+  }
+  out.write(Buffer.alloc(1024, 0))
+  out.end()
+  return new Promise((resolvePromise, rejectPromise) => {
+    out.on('error', rejectPromise)
+    out.on('finish', () => {
+      const gz = createGzip({ mtime: 0 })
+      const input = createReadStream(tempTar)
+      const output = createWriteStream(outFile)
+      input.pipe(gz).pipe(output)
+      output.on('finish', () => {
+        rmSync(dirname(tempTar), { recursive: true, force: true })
+        resolvePromise()
+      })
+      output.on('error', rejectPromise)
+    })
+  })
+}
+
+export async function packagePlugin(argv) {
+  const { args, flags } = parseArgs(argv)
+  const pluginDir = resolve(args[0] || process.cwd())
+  if (flags.get('build') !== false) runPackageScript(pluginDir, 'build')
+  const manifest = validateManifest(pluginDir)
+  const files = collectPackageFiles(pluginDir)
+  const outRoot = resolve(String(flags.get('out') || join(pluginDir, 'dist')))
+  mkdirSync(outRoot, { recursive: true })
+  const base = `${manifest.id}-${manifest.version}.crewcode-plugin.tgz`
+  const outFile = join(outRoot, base)
+  await writeTarGz(pluginDir, files, outFile)
+  const sha256 = createHash('sha256').update(readFileSync(outFile)).digest('hex')
+  writeJson(join(outRoot, `${base}.json`), { id: manifest.id, version: manifest.version, file: base, sha256, files: files.map(f => f.rel) })
+  return { ok: true, path: outFile, sha256, files: files.length }
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const [group, command, ...rest] = argv
+  if (group !== 'plugin' || !command || command === '--help' || command === '-h') {
+    console.log(usage())
+    return { ok: true }
+  }
+  if (command === 'create') return createPlugin(rest)
+  if (command === 'dev') return devPlugin(rest)
+  if (command === 'package') return packagePlugin(rest)
+  if (command === 'list') return listCommand()
+  throw new Error(`unknown command: crewcode plugin ${command}`)
+}
+
+// npm symlinks `bin` entries, so process.argv[1] is the symlink path while
+// import.meta.url is the real one — string-comparing `file://` + argv[1] never
+// matched and main() silently never ran for globally installed users. realpath
+// resolves the symlink; pathToFileURL gets Windows' file:///C:/ form right.
+function isDirectRun() {
+  const entry = process.argv[1]
+  if (!entry) return false
+  try {
+    return import.meta.url === pathToFileURL(realpathSync(entry)).href
+  } catch {
+    return false
+  }
+}
+
+if (isDirectRun()) {
+  main().then(result => {
+    if (result?.path) console.log(result.path)
+  }).catch(err => {
+    console.error(err.message)
+    process.exit(1)
+  })
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "crewcode-plugin-cli",
+  "version": "0.1.0",
+  "description": "Command-line tool for scaffolding, developing, and packaging CrewCode plugins.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "keywords": [
+    "crewcode",
+    "plugin",
+    "cli",
+    "scaffold",
+    "ade",
+    "ai-agents"
+  ],
+  "homepage": "https://github.com/CjLogic/CrewCode/tree/main/packages/crewcode-plugin-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CjLogic/CrewCode.git",
+    "directory": "packages/crewcode-plugin-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/CjLogic/CrewCode/issues"
+  },
+  "bin": {
+    "crewcode": "bin/crewcode.mjs"
+  },
+  "exports": {
+    ".": "./bin/crewcode.mjs"
+  },
+  "scripts": {
+    "test": "vitest run ../../src/main/crewcode-plugin-cli.test.ts",
+    "pack:dry": "npm pack --dry-run"
+  },
+  "files": [
+    "bin",
+    "templates",
+    "LICENSE",
+    "README.md"
+  ]
+}