@biznetgio/neo-app 0.4.12 → 0.4.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@biznetgio/neo-app",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "description": "NEO App CLI — one-command agent onboarding, MCP server, and project ops for coding agents (Codex, Claude Code).",
   "type": "module",
   "bin": {

package/src/commands/deploy.js

@@ -78,6 +78,7 @@ export async function deploy(source, opts = {}) {
     projectId,
     src,
     name: opts.name,
+    serviceType: opts.type,
     port: opts.port,
     build: opts.build,
     environment,

package/src/deploySource.js

@@ -117,13 +117,29 @@ function zipEntryNames(buf) {
   return names;
 }
 
+export const SERVICE_TYPES = ['web', 'worker', 'static_site'];
+
+// A folder with a root index.html and NO server manifest is a static site, not a
+// web service. Used only to fill an UNSET serviceType; an explicit type always
+// wins and the caller logs the detection, so this is never a silent conversion
+// (handoff 4.3). Kept deliberately narrow — a repo with any server manifest
+// (package.json/Dockerfile/go.mod/…) stays a web service.
+const SERVER_MANIFESTS = [
+  'package.json', 'Dockerfile', 'go.mod', 'requirements.txt', 'Pipfile',
+  'pom.xml', 'build.gradle', 'composer.json', 'Gemfile', 'Cargo.toml',
+];
+function looksStatic(dir) {
+  if (!existsSync(join(dir, 'index.html'))) return false;
+  return !SERVER_MANIFESTS.some((m) => existsSync(join(dir, m)));
+}
+
 // deploySource ships a resolved source to a project. `src` is one of:
 //   { mode:'image', image }           { mode:'git', repo, branch? }
 //   { mode:'dir', dir }               { mode:'zip', zipFile }
 // With `dryRun`, it performs NO create/update/upload/deploy — only the GETs needed to
 // build a plan — and returns { dryRun:true, plan } (JNG #93).
 // Returns { pending, approvalId } or { appId, url, result }. `log(msg)` is optional.
-export async function deploySource(api, { projectId, src, name, port, build, environment, dryRun = false, timeout = 300, log = () => {} }) {
+export async function deploySource(api, { projectId, src, name, port, build, serviceType, environment, dryRun = false, timeout = 300, log = () => {} }) {
   const defaultName =
     src.mode === 'image' ? src.image.split('/').pop().split(':')[0]
     : src.mode === 'git' ? basename(src.repo, '.git')
@@ -132,6 +148,25 @@ export async function deploySource(api, { projectId, src, name, port, build, env
   const svc = sanitizeName(name || defaultName);
   const targetEnv = environment || 'production';
 
+  // Resolve the service type (handoff 4.2/4.3): honor an explicit type; else a
+  // plainly-static folder becomes static_site (logged); everything else is web.
+  // A worker never gets a public port/ingress — the control plane strips them,
+  // and we don't send them either.
+  const wantType = serviceType ? String(serviceType).toLowerCase() : '';
+  if (wantType && !SERVICE_TYPES.includes(wantType)) {
+    throw new Error(`invalid serviceType "${serviceType}" — use one of ${SERVICE_TYPES.join(', ')}`);
+  }
+  let svcType = wantType;
+  if (!svcType) {
+    if (src.mode === 'dir' && looksStatic(src.dir)) {
+      svcType = 'static_site';
+      log('detected a static site (root index.html, no server manifest) — deploying as static_site; pass serviceType to override');
+    } else {
+      svcType = 'web';
+    }
+  }
+  const isWorker = svcType === 'worker';
+
   let buildType = 'railpack';
   if (src.mode === 'image') buildType = 'image';
   else if (build) buildType = build;
@@ -171,24 +206,34 @@ export async function deploySource(api, { projectId, src, name, port, build, env
 
   const plan = [];
   if (!app) {
-    plan.push(`create web service "${svc}" (${buildType}) in ${targetEnv}`);
+    plan.push(`create ${svcType} service "${svc}" (${buildType}) in ${targetEnv}`);
     if (!dryRun) {
       const res = await api.post(`/api/v1/projects/${projectId}/apps`, {
         name: svc,
         environment: targetEnv,
-        serviceType: 'web',
+        serviceType: svcType,
         buildType,
         image: src.image || undefined,
         repoUrl: src.repo || undefined,
         branch: src.branch || undefined,
-        port: port ? Number(port) : undefined,
-        tls: true,
+        // A worker has no public listener: don't request a port or TLS/ingress.
+        port: isWorker ? undefined : (port ? Number(port) : undefined),
+        tls: isWorker ? false : true,
       });
       if (pending(res)) return { pending: true, approvalId: res.data.approvalId };
       app = res.data?.application || res.data;
       log(`created service ${svc}`);
     }
   } else {
+    // Never silently convert an existing service's type (handoff 4.2/4.3): if the
+    // caller EXPLICITLY asked for a type that differs, refuse — redeploy keeps the
+    // existing type. (An auto-detected type never triggers this.)
+    if (wantType && app.serviceType && app.serviceType !== svcType) {
+      throw new Error(
+        `service "${svc}" is a ${app.serviceType}, not a ${svcType} — a redeploy keeps its type; ` +
+        `create a new service to deploy as ${svcType}`,
+      );
+    }
     // Existing service: apply requested source changes (image/repo/branch/build) BEFORE
     // deploying, so a redeploy never silently ships the old source config (JNG #96).
     const patch = {};

package/src/index.js

@@ -28,6 +28,7 @@ ${c.bold('Options')}
   --image <ref>            Deploy a prebuilt image (deploy)
   --repo <git-url>         Deploy from a Git repo, built server-side (deploy)
   --name <name>            Service name (deploy; default derived from the source)
+  --type <web|worker|static_site>  Service type (deploy; default web, auto-detects static_site)
   --port <n>               Container port (deploy)
   --agent <codex|claude-code>   Target one agent (config install-mcp)
   --url <url>              Override the control-plane URL (also NEO_APP_URL)
@@ -49,6 +50,7 @@ const options = {
   image: { type: 'string' },
   repo: { type: 'string' },
   name: { type: 'string' },
+  type: { type: 'string' },
   port: { type: 'string' },
   branch: { type: 'string' },
   build: { type: 'string' },

package/src/mcp/server.js

@@ -29,7 +29,7 @@ export async function runMcpServer() {
       name: t.name,
       description: t.description,
       inputSchema: t.schema,
-      annotations: { readOnlyHint: !t.mutating, destructiveHint: false },
+      annotations: { readOnlyHint: !t.mutating, destructiveHint: !!t.destructive },
     })),
   }));
 

package/src/mcp/tools.js

@@ -61,22 +61,22 @@ export const TOOLS = [
       // Honest support matrix: what THIS build does, not the roadmap. `create`
       // is true, false, or 'via_folder' (created through neo_deploy_folder).
       const resourceTypes = [
-        { type: 'web', create: true, deploy: true, scale: true, logs: true, variables: true, delete: false },
-        { type: 'template', create: true, deploy: true, scale: false, logs: true, variables: true, delete: false },
-        { type: 'static_site', create: false, deploy: true, scale: false, logs: true, variables: true, delete: false, note: 'currently planned/created as web (handoff 4.3)' },
-        { type: 'worker', create: false, deploy: true, scale: true, logs: true, variables: true, delete: false, note: 'currently planned/created as web (handoff 4.2)' },
-        { type: 'database', create: false, deploy: false, delete: false, note: 'REST exists; no MCP tool yet (handoff 4.4)' },
-        { type: 'queue', create: false, deploy: false, delete: false, note: 'REST exists; no MCP tool yet (handoff 4.5)' },
-        { type: 'cron', create: false, deploy: false, delete: false, note: 'REST exists; no MCP tool yet (handoff 4.6)' },
-        { type: 'object_storage', create: false, deploy: false, delete: false, note: 'REST exists; no MCP tool yet (handoff 4.7)' },
+        { type: 'web', create: true, deploy: true, scale: true, logs: true, variables: true, delete: true },
+        { type: 'template', create: true, deploy: true, scale: false, logs: true, variables: true, delete: true },
+        { type: 'static_site', create: 'via_folder', deploy: true, scale: false, logs: true, variables: true, delete: true, note: 'neo_deploy_folder serviceType=static_site (auto-detected for static-only folders); auto-detection from a repo/monorepo is still TODO (handoff 6)' },
+        { type: 'worker', create: 'via_folder', deploy: true, scale: true, logs: true, variables: true, delete: true, note: 'neo_deploy_folder serviceType=worker — no public ingress; repo auto-detection still TODO (handoff 6)' },
+        { type: 'database', create: false, deploy: false, delete: true, note: 'neo_delete_database exists; create still has no MCP tool (handoff 4.4)' },
+        { type: 'queue', create: false, deploy: false, delete: true, note: 'neo_delete_queue exists; create still has no MCP tool (handoff 4.5)' },
+        { type: 'cron', create: false, deploy: false, delete: true, note: 'neo_delete_cron exists; create still has no MCP tool (handoff 4.6)' },
+        { type: 'object_storage', create: false, deploy: false, delete: true, note: 'neo_delete_bucket exists; create still has no MCP tool (handoff 4.7)' },
       ];
 
       return {
         mcp: { name: 'neo-app', version: pkgVersion() },
         controlPlane,
         resourceTypes,
-        // Verbs this MCP build exposes today (no create-DB/queue/cron/bucket, no delete, no costed plan/apply yet).
-        lifecycleVerbs: ['list', 'get', 'deploy', 'scale', 'logs', 'get_variables', 'set_variable', 'list_approvals', 'get_approval', 'get_credit', 'list_templates'],
+        // Verbs this MCP build exposes today (no create-DB/queue/cron/bucket, no costed plan/apply yet).
+        lifecycleVerbs: ['list', 'get', 'deploy', 'scale', 'logs', 'get_variables', 'set_variable', 'delete', 'list_approvals', 'get_approval', 'get_credit', 'list_templates'],
         sourceTypes: ['git', 'image', 'dockerfile', 'local', 'template'],
         environments: ['staging', 'production'],
         pricing,
@@ -270,7 +270,7 @@ export const TOOLS = [
   {
     name: 'neo_deploy_folder',
     description:
-      'Deploy a local folder or .zip as a web service in a project (built server-side). The path is on the machine running this MCP server. Pick the environment with `environment` (JNG #72).',
+      'Deploy a local folder or .zip in a project (built server-side). The path is on the machine running this MCP server. Pick the environment with `environment` (JNG #72). Pick the service type with `serviceType`: web (default), worker (background job, no public URL), or static_site; a plainly-static folder auto-detects as static_site. A worker is never given a public port/ingress; its type is never silently changed on redeploy (handoff 4.2/4.3).',
     mutating: true,
     schema: {
       type: 'object',
@@ -278,7 +278,8 @@ export const TOOLS = [
         projectId: str('Project id'),
         path: str('Local folder or .zip path'),
         name: str('Service name (optional)'),
-        port: int('Container port (optional)'),
+        serviceType: { type: 'string', enum: ['web', 'worker', 'static_site'], description: 'web (default) | worker (no public URL) | static_site. Auto-detects static_site for a static-only folder; else web.' },
+        port: int('Container port (optional; ignored for worker)'),
         environment: str('production or staging (optional, default production)'),
         dryRun: { type: 'boolean', description: 'Preview the plan without creating/uploading/deploying anything (JNG #93)' },
       },
@@ -299,6 +300,7 @@ export const TOOLS = [
         projectId: args.projectId,
         src,
         name: args.name,
+        serviceType: args.serviceType,
         port: args.port,
         environment: args.environment || 'production',
         dryRun: !!args.dryRun,
@@ -325,4 +327,62 @@ export const TOOLS = [
       return found;
     },
   },
+  // --- Cleanup (handoff 3.6): MCP can delete every resource type it can reach, so
+  // an agent never leaks a resource it created. These are DESTRUCTIVE and permanent;
+  // the server hard-deletes the record and tears down the running workload. ---
+  {
+    name: 'neo_delete_service',
+    description: 'Permanently delete a service (web / worker / static_site) and tear down its running workload. Destructive and irreversible.',
+    mutating: true,
+    destructive: true,
+    schema: { type: 'object', properties: { appId: str('Service/app id (from neo_list_services)') }, required: ['appId'] },
+    async call(api, args) {
+      const { status, data } = await api.del(`/api/v1/apps/${args.appId}`);
+      return result(status, data);
+    },
+  },
+  {
+    name: 'neo_delete_database',
+    description: 'Permanently delete a managed database and its instance/volume. Destructive and irreversible — the data is not recoverable.',
+    mutating: true,
+    destructive: true,
+    schema: { type: 'object', properties: { databaseId: str('Database id') }, required: ['databaseId'] },
+    async call(api, args) {
+      const { status, data } = await api.del(`/api/v1/databases/${args.databaseId}`);
+      return result(status, data);
+    },
+  },
+  {
+    name: 'neo_delete_queue',
+    description: 'Permanently delete a managed queue and its instance. Destructive and irreversible.',
+    mutating: true,
+    destructive: true,
+    schema: { type: 'object', properties: { queueId: str('Queue id') }, required: ['queueId'] },
+    async call(api, args) {
+      const { status, data } = await api.del(`/api/v1/queues/${args.queueId}`);
+      return result(status, data);
+    },
+  },
+  {
+    name: 'neo_delete_cron',
+    description: 'Permanently delete a scheduled job (cron). Destructive and irreversible.',
+    mutating: true,
+    destructive: true,
+    schema: { type: 'object', properties: { cronId: str('Cron/scheduled-job id') }, required: ['cronId'] },
+    async call(api, args) {
+      const { status, data } = await api.del(`/api/v1/crons/${args.cronId}`);
+      return result(status, data);
+    },
+  },
+  {
+    name: 'neo_delete_bucket',
+    description: 'Permanently delete an object-storage bucket. Destructive and irreversible — bucket contents are lost.',
+    mutating: true,
+    destructive: true,
+    schema: { type: 'object', properties: { bucketId: str('Bucket id') }, required: ['bucketId'] },
+    async call(api, args) {
+      const { status, data } = await api.del(`/api/v1/buckets/${args.bucketId}`);
+      return result(status, data);
+    },
+  },
 ];