@biznetgio/neo-app 0.4.13 → 0.4.15

package/package.json

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

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

@@ -23,6 +23,23 @@ function result(status, data) {
   return data;
 }
 
+// Credentials are write-only (handoff 4.4/4.5/4.7/5): never hand a raw secret
+// (password, connection string, access/secret key, token) back to the agent.
+// Recursively replace any secret-looking value with a reference marker so the
+// agent still sees the resource's shape and non-secret identifiers.
+const SECRET_KEY = /(password|secret|secretkey|accesskey|connectionstring|connstr|dsn|token|privatekey|apikey)/i;
+function redactSecrets(value) {
+  if (Array.isArray(value)) return value.map(redactSecrets);
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = SECRET_KEY.test(k) ? '[redacted — credentials are write-only; bind them to a consumer instead]' : redactSecrets(v);
+    }
+    return out;
+  }
+  return value;
+}
+
 export const TOOLS = [
   {
     name: 'neo_whoami',
@@ -61,22 +78,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: 'via_folder', deploy: true, scale: false, logs: true, variables: true, delete: false, 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: false, note: 'neo_deploy_folder serviceType=worker — no public ingress; repo auto-detection still TODO (handoff 6)' },
-        { 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: true, get: true, list: true, delete: true, note: 'neo_create/list/get/delete_database (0.4.15); update/plan still TODO (handoff 4.4)' },
+        { type: 'queue', create: true, get: true, list: true, delete: true, note: 'neo_create/list/get/delete_queue (0.4.15); update/plan still TODO (handoff 4.5)' },
+        { type: 'cron', create: true, get: true, list: true, delete: true, note: 'neo_create/list/get/delete_cron (0.4.15); manual-run/history still TODO (handoff 4.6)' },
+        { type: 'object_storage', create: true, get: true, list: true, delete: true, note: 'neo_create/list/get/delete_bucket (0.4.15); object put/get still TODO (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: ['create', '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,
@@ -327,4 +344,233 @@ export const TOOLS = [
       return found;
     },
   },
+  // --- Managed resources (handoff 4.4-4.7): create/list/get for DB, Queue, Cron,
+  // Object Storage. Credentials in responses are redacted (write-only). A member's
+  // create may return pending_approval (202) — surfaced verbatim, not an error. ---
+  {
+    name: 'neo_create_database',
+    description: 'Create a managed database in a project (handoff 4.4). Returns the resource (credentials redacted); poll neo_get_database for readiness, then deploy via REST/portal if needed. May return pending_approval.',
+    mutating: true,
+    schema: {
+      type: 'object',
+      properties: {
+        projectId: str('Project id'),
+        name: str('Database name'),
+        engine: { type: 'string', description: 'postgres | mysql (engine)' },
+        version: str('Engine version, e.g. "16" (optional)'),
+        environment: str('production or staging (optional, default production)'),
+        volumeSize: str('Storage size, e.g. "10Gi" (optional)'),
+        replicas: int('Read/failover replicas for HA (optional; postgres/CNPG only)'),
+        deploymentMode: { type: 'string', description: 'single | ha (optional)' },
+      },
+      required: ['projectId', 'name', 'engine'],
+    },
+    async call(api, args) {
+      const { projectId, ...body } = args;
+      const { status, data } = await api.post(`/api/v1/projects/${projectId}/databases`, body);
+      return redactSecrets(result(status, data));
+    },
+  },
+  {
+    name: 'neo_list_databases',
+    description: 'List managed databases in a project (credentials redacted).',
+    mutating: false,
+    schema: { type: 'object', properties: { projectId: str('Project id') }, required: ['projectId'] },
+    async call(api, args) {
+      return redactSecrets((await api.get(`/api/v1/projects/${args.projectId}/databases`)).data);
+    },
+  },
+  {
+    name: 'neo_get_database',
+    description: 'Get one managed database by id, including provisioning/readiness state (credentials redacted — bind them to a consumer instead).',
+    mutating: false,
+    schema: { type: 'object', properties: { databaseId: str('Database id') }, required: ['databaseId'] },
+    async call(api, args) {
+      return redactSecrets((await api.get(`/api/v1/databases/${args.databaseId}`)).data);
+    },
+  },
+  {
+    name: 'neo_create_queue',
+    description: 'Create a managed queue in a project (handoff 4.5). Credentials redacted. May return pending_approval.',
+    mutating: true,
+    schema: {
+      type: 'object',
+      properties: {
+        projectId: str('Project id'),
+        name: str('Queue name'),
+        planClass: str('Plan/engine class (optional)'),
+        environment: str('production or staging (optional, default production)'),
+        volumeSize: str('Storage size, e.g. "10Gi" (optional)'),
+        dlqEnabled: { type: 'boolean', description: 'Enable a dead-letter queue (optional)' },
+      },
+      required: ['projectId', 'name'],
+    },
+    async call(api, args) {
+      const { projectId, ...body } = args;
+      const { status, data } = await api.post(`/api/v1/projects/${projectId}/queues`, body);
+      return redactSecrets(result(status, data));
+    },
+  },
+  {
+    name: 'neo_list_queues',
+    description: 'List managed queues in a project (credentials redacted).',
+    mutating: false,
+    schema: { type: 'object', properties: { projectId: str('Project id') }, required: ['projectId'] },
+    async call(api, args) {
+      return redactSecrets((await api.get(`/api/v1/projects/${args.projectId}/queues`)).data);
+    },
+  },
+  {
+    name: 'neo_get_queue',
+    description: 'Get one managed queue by id, including readiness (credentials redacted).',
+    mutating: false,
+    schema: { type: 'object', properties: { queueId: str('Queue id') }, required: ['queueId'] },
+    async call(api, args) {
+      return redactSecrets((await api.get(`/api/v1/queues/${args.queueId}`)).data);
+    },
+  },
+  {
+    name: 'neo_create_cron',
+    description: 'Create a scheduled job (cron) in a project (handoff 4.6). Target is either an existing service command (mode=app_command, serviceId+command) or an HTTP endpoint (mode=http_endpoint, url+method). Schedule via scheduleType (cron|interval|once|seconds) + schedule/intervalMinutes. May return pending_approval.',
+    mutating: true,
+    schema: {
+      type: 'object',
+      properties: {
+        projectId: str('Project id'),
+        name: str('Job name'),
+        mode: { type: 'string', description: 'app_command | http_endpoint' },
+        scheduleType: { type: 'string', description: 'cron | interval | once | seconds' },
+        schedule: str('Cron expression (when scheduleType=cron), e.g. "0 * * * *"'),
+        intervalMinutes: int('Interval in minutes (when scheduleType=interval)'),
+        timezone: str('IANA timezone, e.g. "Asia/Jakarta" (optional)'),
+        serviceId: str('Target service id (mode=app_command)'),
+        image: str('Image to run (mode=app_command, if not targeting a service)'),
+        command: { type: 'array', items: { type: 'string' }, description: 'Command argv (mode=app_command)' },
+        url: str('Target URL (mode=http_endpoint)'),
+        method: str('HTTP method (mode=http_endpoint), e.g. GET/POST'),
+        environment: str('production or staging (optional, default production)'),
+      },
+      required: ['projectId', 'name', 'mode', 'scheduleType'],
+    },
+    async call(api, args) {
+      const { projectId, ...body } = args;
+      const { status, data } = await api.post(`/api/v1/projects/${projectId}/crons`, body);
+      return redactSecrets(result(status, data));
+    },
+  },
+  {
+    name: 'neo_list_crons',
+    description: 'List scheduled jobs (crons) in a project.',
+    mutating: false,
+    schema: { type: 'object', properties: { projectId: str('Project id') }, required: ['projectId'] },
+    async call(api, args) {
+      return redactSecrets((await api.get(`/api/v1/projects/${args.projectId}/crons`)).data);
+    },
+  },
+  {
+    name: 'neo_get_cron',
+    description: 'Get one scheduled job (cron) by id, including its schedule and last run.',
+    mutating: false,
+    schema: { type: 'object', properties: { cronId: str('Cron/scheduled-job id') }, required: ['cronId'] },
+    async call(api, args) {
+      return redactSecrets((await api.get(`/api/v1/crons/${args.cronId}`)).data);
+    },
+  },
+  {
+    name: 'neo_create_bucket',
+    description: 'Create an S3-compatible object-storage bucket in a project (handoff 4.7). Access keys are provisioned server-side and are NOT returned (write-only). May return pending_approval.',
+    mutating: true,
+    schema: {
+      type: 'object',
+      properties: {
+        projectId: str('Project id'),
+        name: str('Bucket name'),
+        region: str('Region (optional; see neo_list_regions on the portal)'),
+        acl: { type: 'string', description: 'private | public-read (optional, default private)' },
+        quotaGB: int('Storage quota in GB (optional)'),
+      },
+      required: ['projectId', 'name'],
+    },
+    async call(api, args) {
+      const { projectId, ...body } = args;
+      const { status, data } = await api.post(`/api/v1/projects/${projectId}/buckets`, body);
+      return redactSecrets(result(status, data));
+    },
+  },
+  {
+    name: 'neo_list_buckets',
+    description: 'List object-storage buckets in a project.',
+    mutating: false,
+    schema: { type: 'object', properties: { projectId: str('Project id') }, required: ['projectId'] },
+    async call(api, args) {
+      return redactSecrets((await api.get(`/api/v1/projects/${args.projectId}/buckets`)).data);
+    },
+  },
+  {
+    name: 'neo_get_bucket',
+    description: 'Get one object-storage bucket by id (access keys not returned — write-only).',
+    mutating: false,
+    schema: { type: 'object', properties: { bucketId: str('Bucket id') }, required: ['bucketId'] },
+    async call(api, args) {
+      return redactSecrets((await api.get(`/api/v1/buckets/${args.bucketId}`)).data);
+    },
+  },
+  // --- 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);
+    },
+  },
 ];