jira-cli-toolkit 2.5.1__py3-none-any.whl

jsup/credentials.py

@@ -0,0 +1,125 @@
+"""Credential storage with no implicit plaintext fallback."""
+from __future__ import annotations
+
+import json
+from contextlib import contextmanager
+from pathlib import Path
+from threading import RLock
+
+SERVICE = "jira-cli-toolkit"
+_STORE_LOCK = RLock()
+
+
+class CredentialError(ValueError):
+    pass
+
+
+def _keyring():
+    try:
+        import keyring
+        backend = keyring.get_keyring()
+        module = type(backend).__module__
+        # Accept only native OS stores; chained/plaintext third-party stores
+        # are not an implicit downgrade from secure storage.
+        trusted={"keyring.backends.macOS", "keyring.backends.Windows",
+                 "keyring.backends.SecretService", "keyring.backends.kwallet"}
+        if module in trusted:
+            return backend
+        for candidate in getattr(backend, "backends", []):
+            if type(candidate).__module__ in trusted and candidate.priority > 0:
+                return candidate
+        raise CredentialError("No native credential store available. Use JIRA_API_TOKEN for headless use, or explicitly choose --storage file.")
+    except ImportError:
+        raise CredentialError("Credential-store support is missing; reinstall the package or use environment authentication.") from None
+
+
+@contextmanager
+def _store(allow_ui):
+    """Keep OS unlock dialogs out of scripted commands.
+
+    keyring 25 targets the macOS file-based Keychain, whose process-wide
+    interaction flag must be restored even if an operation fails.
+    """
+    backend = _keyring()
+    module = type(backend).__module__
+    if allow_ui or module == "keyring.backends.Windows":
+        yield backend
+        return
+    if module == "keyring.backends.macOS":
+        import ctypes
+        from keyring.backends.macOS import api
+        get_ui = api._sec.SecKeychainGetUserInteractionAllowed
+        set_ui = api._sec.SecKeychainSetUserInteractionAllowed
+        get_ui.argtypes = [ctypes.POINTER(ctypes.c_ubyte)]
+        set_ui.argtypes = [ctypes.c_ubyte]
+        get_ui.restype = set_ui.restype = ctypes.c_int32
+        with _STORE_LOCK:
+            previous = ctypes.c_ubyte()
+            api.Error.raise_for_status(get_ui(ctypes.byref(previous)))
+            api.Error.raise_for_status(set_ui(False))
+            try:
+                yield backend
+            finally:
+                api.Error.raise_for_status(set_ui(previous.value))
+        return
+    # Linux backends can create/unlock a wallet through an unbounded D-Bus
+    # prompt. Scripted use must choose an explicit noninteractive source.
+    raise CredentialError("This OS store can request an unlock dialog. Use environment authentication or explicitly choose --storage file for headless use; run auth login in a terminal for native storage.")
+
+
+def get(profile, settings, config_path, *, allow_ui=False):
+    storage = settings.get("storage", "keyring")
+    if storage == "keyring":
+        try:
+            with _store(allow_ui) as backend:
+                return backend.get_password(SERVICE, settings["credential_id"]) or ""
+        except CredentialError:
+            raise
+        except Exception:
+            raise CredentialError("Could not read the OS credential store without approved access. Run auth login interactively or use environment authentication.") from None
+    path = Path(config_path).with_name("credentials.json")
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            raise CredentialError("Invalid credential file.")
+        return data.get(settings["credential_id"], "")
+    except FileNotFoundError:
+        return ""
+    except json.JSONDecodeError:
+        raise CredentialError("Invalid credential file.") from None
+
+
+def put(settings, token, config_path, *, allow_ui=False):
+    if settings["storage"] == "keyring":
+        try:
+            with _store(allow_ui) as backend:
+                backend.set_password(SERVICE, settings["credential_id"], token)
+            return
+        except CredentialError:
+            raise
+        except Exception:
+            raise CredentialError("Could not save to the OS credential store. Run auth login interactively to approve access, use environment authentication, or explicitly choose --storage file (POSIX only). No plaintext fallback was written.") from None
+    import os
+    if os.name == "nt":
+        raise CredentialError("File storage on Windows is unsupported until ACL protection is implemented; use the Windows credential store or environment variables.")
+    from .config import atomic_json
+    path = Path(config_path).with_name("credentials.json")
+    data = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
+    data[settings["credential_id"]] = token
+    atomic_json(path, data)
+
+
+def delete(settings, config_path, *, allow_ui=False):
+    if settings["storage"] == "keyring":
+        try:
+            with _store(allow_ui) as backend:
+                backend.delete_password(SERVICE, settings["credential_id"])
+        except Exception:
+            raise CredentialError("Could not remove the OS credential. Unlock the store and retry logout.") from None
+    else:
+        from .config import atomic_json
+        path = Path(config_path).with_name("credentials.json")
+        if path.exists():
+            data = json.loads(path.read_text(encoding="utf-8"))
+            data.pop(settings["credential_id"], None)
+            atomic_json(path, data)

jsup/data/callback.json

@@ -0,0 +1,13 @@
+{
+  "schema_version": 1,
+  "name": "callback",
+  "type": "Task",
+  "summary": "Callback: {name} — {issue}",
+  "description": "Client: {name}\nIssue as reported: {issue}\nRequested callback: {callback}\nSource: jsup intake. Assumed open — team to review & update.",
+  "fields": {"priority": "High", "labels": ["callback"], "components": ["ops-runbook"]},
+  "variables": [
+    {"name": "name", "prompt": "Client name", "required": true},
+    {"name": "issue", "prompt": "Issue as reported", "required": true},
+    {"name": "callback", "prompt": "Requested callback", "default": "not specified"}
+  ]
+}

jsup/fields.py

@@ -0,0 +1,204 @@
+"""Metadata-aware field input; arbitrary validators remain Jira's responsibility."""
+from __future__ import annotations
+
+from datetime import date
+import hashlib
+import json
+from pathlib import Path
+import shlex
+import subprocess
+import os
+import sys
+import tempfile
+import time
+
+from . import config, ui
+from .client import adf, JiraError
+
+TTL=300
+
+
+def cached(cfg,project,kind,fetch,refresh=False):
+    identity=[cfg['site'],cfg.get('email'),cfg.get('profile'),project,kind]
+    key=hashlib.sha256(json.dumps(identity).encode()).hexdigest()
+    path=config.CONFIG_PATH.parent/'cache'/(key+'.json')
+    if not refresh:
+        try:
+            entry=json.loads(path.read_text(encoding="utf-8"))
+            if 0<=time.time()-entry['saved_at']<TTL:
+                return entry['data']
+        except (OSError,ValueError,KeyError,TypeError): pass
+    data=fetch()
+    try: config.atomic_json(path,{'saved_at':time.time(),'data':data})
+    except OSError: pass  # Cache availability must not block Jira operations.
+    return data
+
+
+def invalidate(cfg):
+    # Invalidate this CLI's metadata cache after a validation failure.
+    for path in (config.CONFIG_PATH.parent/'cache').glob('*.json'):
+        try: path.unlink()
+        except OSError: pass
+
+
+def choose(items,value,label):
+    if not isinstance(items,list) or any(not isinstance(i,dict) or 'id' not in i for i in items):
+        raise ValueError('Jira returned invalid value metadata.')
+    if value is None: raise ValueError(f'Pass {label}; available values: '+', '.join(f"{i['name']} [id:{i['id']}]" for i in items))
+    raw=str(value).removeprefix('id:')
+    exact=[i for i in items if str(i.get('id'))==raw]
+    matches=exact or [i for i in items if str(i.get('name',i.get('value',''))).casefold()==raw.casefold()]
+    if len(matches)!=1:
+        raise ValueError(f'{label} {value!r} is unavailable or ambiguous; use an explicit ID. Available: '+', '.join(f"{i.get('name',i.get('value',''))} [id:{i.get('id')}]" for i in items))
+    return matches[0]
+
+
+def normalize(meta):
+    if isinstance(meta,dict):
+        if any(not isinstance(value,dict) for value in meta.values()):
+            raise ValueError('Jira returned invalid field metadata.')
+        return meta
+    if not isinstance(meta,list) or any(not isinstance(item,dict) or not (item.get('fieldId') or item.get('key')) for item in meta):
+        raise ValueError('Jira returned invalid field metadata.')
+    return {item.get('fieldId') or item['key']:item for item in meta}
+
+
+def field_key(meta,key):
+    if key in meta: return key
+    matches=[fid for fid,f in meta.items() if f.get('name','').casefold()==key.casefold()]
+    if len(matches)!=1: raise ValueError(f'Unknown or ambiguous field {key!r}; use its field ID (project fields).')
+    return matches[0]
+
+
+def typed(field,value):
+    schema=field.get('schema',{}); kind=schema.get('type')
+    if value is None: return None
+    if isinstance(value,(dict,list,int,float,bool)):
+        return value  # Explicit structured values are passed intact for Jira validation.
+    if kind=='array':
+        values=value.split(',')
+        element={**field,'schema':{**schema,'type':schema.get('items')}}
+        return [typed(element,v.strip()) for v in values if v.strip()]
+    allowed=field.get('allowedValues',[])
+    if allowed:
+        if isinstance(allowed[0],str):
+            matches=[option for option in allowed if option.casefold()==value.casefold()]
+            if len(matches)!=1: raise ValueError(f"{field.get('name')}: value is not allowed.")
+            return matches[0]
+        item=choose(allowed,value,field.get('name','field'))
+        if isinstance(item,dict):
+            return {'id':str(item['id'])} if 'id' in item else {'value':item.get('value',item.get('name'))}
+        return item
+    if kind in ('number','integer'):
+        try: return int(value) if kind=='integer' else float(value)
+        except ValueError: raise ValueError(f"{field.get('name')}: expected a number.") from None
+    if kind=='date':
+        try: return date.fromisoformat(value).isoformat()
+        except ValueError: raise ValueError(f"{field.get('name')}: use YYYY-MM-DD.") from None
+    if kind=='user': return {'accountId':value.removeprefix('id:')}
+    if kind in ('priority','component','option','issuetype','resolution','version'):
+        if not value.startswith('id:'): raise ValueError(f"{field.get('name')}: pass id:<ID> or structured JSON; no allowed-value names were returned.")
+        return {'id':value[3:]}
+    if field.get('key')=='description' or schema.get('system')=='description' or schema.get('custom','').endswith(':textarea'):
+        return adf(value)
+    if kind in ('string',None): return value
+    if kind=='issuelink': return {'key':value}
+    raise ValueError(f"{field.get('name')}: unsupported field format ({kind}); supply a structured JSON value using --field FIELD:=JSON or --fields-file.")
+
+
+def supplied(args,meta):
+    values={}
+    if getattr(args,'fields_file',None):
+        values=json.loads(Path(args.fields_file).read_text(encoding="utf-8"))
+        if not isinstance(values,dict): raise ValueError('--fields-file must contain a JSON object of field values.')
+    for entry in getattr(args,'field',[]):
+        separator=':=' if ':=' in entry else '='
+        key,found,value=entry.partition(separator)
+        if not found or not key: raise ValueError('Use --field FIELD=VALUE or FIELD:=JSON.')
+        values[key]=json.loads(value) if separator==':=' else value
+    result={}
+    for key,value in values.items():
+        fid=field_key(meta,key)
+        if fid in result: raise ValueError(f'Duplicate values refer to field {fid}; use one ID/name.')
+        result[fid]=typed(meta[fid],value)
+    return result
+
+
+def description(args):
+    if getattr(args,'desc_file',None): return Path(args.desc_file).read_text(encoding="utf-8")
+    if getattr(args,'editor',False):
+        if args.no_input or args.json or not sys.stdin.isatty(): raise ValueError('--editor requires interactive input without --json.')
+        editor=os.getenv('VISUAL') or os.getenv('EDITOR')
+        if not editor: raise ValueError('Set VISUAL or EDITOR before using --editor.')
+        with tempfile.TemporaryDirectory(prefix='jira-editor-') as temp:
+            path=Path(temp)/'description.txt'; path.write_text(getattr(args,'desc',None) or '', encoding='utf-8')
+            try: subprocess.run([*shlex.split(editor),str(path)],check=True)
+            except subprocess.SubprocessError: raise ValueError('Editor failed; no Jira operation was submitted.') from None
+            return path.read_text(encoding="utf-8")
+    return getattr(args,'desc',None)
+
+
+def require_fields(args,meta,fields):
+    missing=[key for key,f in meta.items() if f.get('required') and not f.get('hasDefaultValue') and fields.get(key) in (None,'',[])]
+    if missing and (args.no_input or args.json or not sys.stdin.isatty()):
+        raise ValueError('Required fields missing: '+', '.join(f"{meta[k].get('name',k)} ({k})" for k in missing)+'. Supply --field FIELD=VALUE or --fields-file.')
+    for key in missing:
+        field=meta[key]; allowed=field.get('allowedValues',[])
+        if allowed:
+            index=ui.pick(field.get('name',key),[f"{v.get('name',v.get('value'))} [id:{v.get('id')}]" for v in allowed])
+            fields[key]=typed(field,'id:'+str(allowed[index]['id']))
+        else:
+            fields[key]=typed(field,input(f"{field.get('name',key)} ({key}): ").strip())
+            if fields[key] in (None,'',[]): raise ValueError(f'Required field {key} cannot be empty.')
+
+
+def prepare_create(j,args,cfg):
+    project=cfg['project']
+    if not project: raise ValueError('Select a project with --project or context use.')
+    types=cached(cfg,project,'types',lambda:j.issue_types(project),args.refresh)
+    issue_type=args.type
+    if not issue_type and not args.no_input and not args.json and sys.stdin.isatty():
+        issue_type=types[ui.pick('Issue type',[f"{i['name']} [{i['id']}]" for i in types])]['id']
+    selected=choose(types,issue_type,'--type')
+    meta=normalize(cached(cfg,project,'create:'+selected['id'],lambda:j.create_fields(project,selected['id']),args.refresh))
+    provided=supplied(args,meta)
+    explicit={'summary':args.summary,'description':description(args),'priority':args.priority,
+              'assignee':args.assignee,'labels':args.label or None,'components':args.component or None,'parent':args.parent}
+    fields={}
+    for key,value in getattr(args,'template_fields',{}).items():
+        fid=field_key(meta,key)
+        if fid in provided or explicit.get(fid) is not None:
+            continue
+        if isinstance(value,list) and all(isinstance(v,str) for v in value): value=','.join(value)
+        fields[fid]=typed(meta[fid],value)
+    fields.update(provided)
+    if 'project' in fields or 'issuetype' in fields: raise ValueError('Select project/type with --project and --type, not --field.')
+    fields.update(project={'key':project},issuetype={'id':selected['id']})
+    for key,value in explicit.items():
+        if value is not None:
+            if key not in meta: raise ValueError(f'Field {key} is not available for creation in this project/type.')
+            if key in ('parent',): fields[key]={'key':value}
+            else: fields[key]=typed(meta[key],','.join(value) if isinstance(value,list) else value)
+    require_fields(args,meta,fields)
+    return fields
+
+
+def create(j,args,cfg):
+    if getattr(args,'template',None):
+        from .templates import apply
+        apply(args)
+    fields=prepare_create(j,args,cfg)
+    try: return j.create_with_fields(fields)
+    except JiraError as error:
+        if error.status in (400,422): invalidate(cfg)
+        raise
+
+
+def transition(j,args,cfg):
+    transitions=j.transition_fields(args.key).get('transitions',[])
+    selected=choose(transitions,args.to,'--to')
+    meta=normalize(selected.get('fields',{}))
+    fields=supplied(args,meta)
+    require_fields(args,meta,fields)
+    result=j.transition_with_fields(args.key,selected['id'],fields)
+    return {**result, 'moved':args.key, 'to':selected['name']}

jsup/maintenance.py

@@ -0,0 +1,105 @@
+"""Issue maintenance with metadata validation and explicit destructive actions."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from types import SimpleNamespace
+
+from . import fields
+from .client import JiraError, project_jql
+
+
+def edit(j,args,cfg):
+    meta=fields.normalize(j.edit_fields(args.key))
+    values=fields.supplied(args,meta)
+    explicit={'summary':args.summary,'description':fields.description(args),'priority':args.priority,
+              'duedate':args.due_date,'parent':args.parent}
+    for key,value in explicit.items():
+        if value is not None:
+            if key not in meta: raise ValueError(f'Field {key} is not editable on this issue.')
+            values[key]={'key':value} if key=='parent' else fields.typed(meta[key],value)
+    updates={}
+    for singular,plural in [('label','labels'),('component','components')]:
+        replace=getattr(args,singular); add=getattr(args,'add_'+singular); remove=getattr(args,'remove_'+singular)
+        if replace and (add or remove): raise ValueError(f'Use either --{singular} replacement or add/remove operations.')
+        if (replace or add or remove) and plural not in meta: raise ValueError(f'Field {plural} is not editable.')
+        if replace: values[plural]=fields.typed(meta[plural],','.join(replace))
+        if add or remove:
+            if plural in values: raise ValueError(f'Field {plural} cannot be both replaced and incrementally updated.')
+            permitted=meta[plural].get('operations',[])
+            for operation,items in [('add',add),('remove',remove)]:
+                if items and operation not in permitted: raise ValueError(f'Jira does not allow {operation} on {plural} for this issue.')
+                element={**meta[plural],'schema':{**meta[plural].get('schema',{}),'type':meta[plural].get('schema',{}).get('items')}}
+                updates.setdefault(plural,[]).extend({operation:fields.typed(element,item)} for item in items)
+    if not values and not updates: raise ValueError('No changes supplied. Use issue edit --help.')
+    for key,value in values.items():
+        if meta[key].get('required') and value in (None,'',[]): raise ValueError(f'Required field {key} cannot be cleared.')
+        if 'set' not in meta[key].get('operations',['set']): raise ValueError(f'Jira does not allow setting {key}.')
+    try: return j.edit_issue(args.key,values,updates or None)
+    except JiraError as error:
+        if error.status in (400,422): fields.invalidate(cfg)
+        raise
+
+
+def body(args):
+    if args.message is not None: return args.message
+    if getattr(args,'message_file',None): return Path(args.message_file).read_text(encoding="utf-8")
+    if getattr(args,'editor',False):
+        proxy=SimpleNamespace(desc=None,desc_file=None,editor=True,json=args.json,no_input=args.no_input)
+        return fields.description(proxy)
+    raise ValueError('Supply --message, --message-file, or interactive --editor.')
+
+
+def issue_list(j,args,cfg):
+    filters=bool(args.open or args.project or args.assignee or args.status or args.type or args.label or args.board)
+    if args.jql:
+        if filters or args.order_by!='updated' or args.order!='desc': raise ValueError('--jql is a complete query; omit generated filters and ordering flags.')
+        jql=args.jql
+    else:
+        clauses=[]
+        project=args.project or (None if args.board else cfg['project'])
+        if not project and not args.board: raise ValueError('Select --project or --board, or supply complete --jql.')
+        if project: clauses.append(project_jql(project))
+        if args.open: clauses.append('statusCategory != Done')
+        if args.assignee: clauses.append('assignee = '+('currentUser()' if args.assignee=='me' else json.dumps(args.assignee.removeprefix('id:'))))
+        if args.status: clauses.append('status IN ('+', '.join(json.dumps(s) for s in args.status)+')')
+        if args.type: clauses.append('issuetype = '+json.dumps(args.type))
+        for label in args.label: clauses.append('labels = '+json.dumps(label))
+        jql=' AND '.join(clauses)+f' ORDER BY {args.order_by} {args.order.upper()}'
+        jql=jql.strip()
+    options={}
+    if getattr(args,'all',False): options['all_results']=True
+    if args.fields: options['fields']=args.fields
+    if args.board: return j.board_issues(args.board,jql,args.max,**options)
+    return j.search(jql,args.max,**options)
+
+
+def handle(j,args,cfg):
+    cmd=args.cmd
+    if cmd=='issue-edit': return edit(j,args,cfg)
+    if cmd=='issue-unassign': return j.assign(args.key,None)
+    if cmd=='issue-assign':
+        if args.user=='me': account=j.me()['accountId']
+        elif args.user.startswith('id:'): account=args.user[3:]
+        else:
+            candidates=j.assignable_users(args.key,args.user)
+            matches=[u for u in candidates if args.user.casefold() in (u.get('displayName','').casefold(),u.get('emailAddress','').casefold())]
+            if len(matches)!=1: raise ValueError('User is unavailable or ambiguous; use --user id:<account ID>.')
+            account=matches[0]['accountId']
+        if not account: raise ValueError('A nonempty account ID is required.')
+        return j.assign(args.key,account)
+    if cmd=='issue-link':
+        kind=fields.choose(j.link_types(),args.type,'--type')
+        inward,outward=(args.other,args.key) if args.direction=='outward' else (args.key,args.other)
+        return j.link(inward,outward,kind['id'])
+    if cmd=='issue-unlink': return j.unlink(args.id)
+    if cmd in ('comment-add','comment-edit'):
+        text=body(args)
+        if not text.strip(): raise ValueError('Comment body cannot be empty.')
+        return j.comment_add(args.key,text) if cmd=='comment-add' else j.comment_edit(args.key,args.comment_id,text)
+    if cmd=='comment-delete': return j.comment_delete(args.key,args.comment_id)
+    if cmd=='attachment-list': return j.issue_get(args.key).get('fields',{}).get('attachment',[])
+    if cmd=='attachment-upload': return j.attachment_upload(args.key,args.files)
+    if cmd=='attachment-download': return j.attachment_download(args.id,args.output)
+    if cmd=='attachment-delete': return j.attachment_delete(args.id)
+    raise ValueError('Unsupported maintenance operation.')

jsup/templates.py

@@ -0,0 +1,89 @@
+"""Versioned, non-executable team templates."""
+from __future__ import annotations
+
+import copy
+from importlib.resources import files
+import json
+from pathlib import Path
+import re
+import string
+import sys
+
+from . import config
+
+ALLOWED={'schema_version','name','type','summary','description','fields','variables'}
+
+
+def load(name):
+    if name=='callback':
+        data=json.loads(files('jsup').joinpath('data/callback.json').read_text(encoding="utf-8"))
+    else:
+        path=Path(name)
+        if path.suffix!='.json' and len(path.parts)==1:
+            if not re.fullmatch(r'[a-zA-Z0-9_-]+',name): raise ValueError('Invalid template name.')
+            path=config.CONFIG_PATH.parent/'templates'/(name+'.json')
+        data=json.loads(path.read_text(encoding="utf-8"))
+    validate(data)
+    return data
+
+
+def validate(data):
+    if not isinstance(data,dict) or data.get('schema_version')!=1 or set(data)-ALLOWED:
+        raise ValueError('Unsupported template schema/keys. Templates cannot contain hooks or credentials.')
+    if not isinstance(data.get('fields',{}),dict) or not isinstance(data.get('variables',[]),list):
+        raise ValueError('Template fields must be an object and variables a list.')
+    names=set()
+    for variable in data.get('variables',[]):
+        if not isinstance(variable,dict) or set(variable)-{'name','prompt','required','default'}:
+            raise ValueError('Invalid template variable.')
+        name=variable.get('name','')
+        if not re.fullmatch(r'[a-zA-Z_][a-zA-Z0-9_]*',name) or name in names:
+            raise ValueError('Invalid or duplicate template variable name.')
+        names.add(name)
+    for key in ('summary','description'):
+        if key in data:
+            if not isinstance(data[key],str): raise ValueError('Template summary/description must be strings.')
+            try:
+                for literal,name,spec,conversion in string.Formatter().parse(data[key]):
+                    if name is not None and (name not in names or spec or conversion):
+                        raise ValueError('Template placeholders must be declared simple variable names; expressions are unsupported.')
+            except ValueError:
+                raise ValueError('Invalid template pattern or placeholder.') from None
+    return data
+
+
+def render(data,variables):
+    validate(data)
+    declared={v['name']:v for v in data.get('variables',[])}
+    if set(variables)-set(declared): raise ValueError('Unknown template variables: '+', '.join(sorted(set(variables)-set(declared))))
+    resolved={name:variables.get(name,entry.get('default','')) for name,entry in declared.items()}
+    missing=[name for name,entry in declared.items() if entry.get('required') and not resolved[name]]
+    if missing: raise ValueError('Missing template variables: '+', '.join(missing))
+    fields=copy.deepcopy(data.get('fields',{}))
+    if 'summary' in data: fields['summary']=data['summary'].format_map(resolved)
+    if 'description' in data: fields['description']=data['description'].format_map(resolved)
+    return fields
+
+
+def apply(args, *, validating=False):
+    data=load(args.template)
+    values={}
+    for item in args.var:
+        key,sep,value=item.partition('=')
+        if not sep: raise ValueError('Use --var NAME=VALUE.')
+        values[key]=value
+    for variable in data.get('variables',[]):
+        name=variable['name']
+        if name not in values and variable.get('required'):
+            if validating:
+                values[name]='example'
+            elif not args.no_input and not args.json and sys.stdin.isatty():
+                values[name]=input(variable.get('prompt',name)+': ').strip()
+    args.template_fields=render(data,values)
+    if not args.type: args.type=data.get('type')
+    return args
+
+
+def list_templates():
+    local=config.CONFIG_PATH.parent/'templates'
+    return {'templates':['callback']+sorted(p.stem for p in local.glob('*.json') if p.stem!='callback')}